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

#ifndef GOOGLE_PROTOBUF_INCLUDED_netmessages_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_netmessages_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021008 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "networkbasetypes.pb.h"
#include "source2_steam_stats.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_netmessages_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_netmessages_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_netmessages_2eproto;
class CBidirMsg_PredictionEvent;
struct CBidirMsg_PredictionEventDefaultTypeInternal;
extern CBidirMsg_PredictionEventDefaultTypeInternal _CBidirMsg_PredictionEvent_default_instance_;
class CBidirMsg_RebroadcastGameEvent;
struct CBidirMsg_RebroadcastGameEventDefaultTypeInternal;
extern CBidirMsg_RebroadcastGameEventDefaultTypeInternal _CBidirMsg_RebroadcastGameEvent_default_instance_;
class CBidirMsg_RebroadcastSource;
struct CBidirMsg_RebroadcastSourceDefaultTypeInternal;
extern CBidirMsg_RebroadcastSourceDefaultTypeInternal _CBidirMsg_RebroadcastSource_default_instance_;
class CCLCMsg_BaselineAck;
struct CCLCMsg_BaselineAckDefaultTypeInternal;
extern CCLCMsg_BaselineAckDefaultTypeInternal _CCLCMsg_BaselineAck_default_instance_;
class CCLCMsg_ClientInfo;
struct CCLCMsg_ClientInfoDefaultTypeInternal;
extern CCLCMsg_ClientInfoDefaultTypeInternal _CCLCMsg_ClientInfo_default_instance_;
class CCLCMsg_CmdKeyValues;
struct CCLCMsg_CmdKeyValuesDefaultTypeInternal;
extern CCLCMsg_CmdKeyValuesDefaultTypeInternal _CCLCMsg_CmdKeyValues_default_instance_;
class CCLCMsg_Diagnostic;
struct CCLCMsg_DiagnosticDefaultTypeInternal;
extern CCLCMsg_DiagnosticDefaultTypeInternal _CCLCMsg_Diagnostic_default_instance_;
class CCLCMsg_HltvFixupOperatorTick;
struct CCLCMsg_HltvFixupOperatorTickDefaultTypeInternal;
extern CCLCMsg_HltvFixupOperatorTickDefaultTypeInternal _CCLCMsg_HltvFixupOperatorTick_default_instance_;
class CCLCMsg_HltvReplay;
struct CCLCMsg_HltvReplayDefaultTypeInternal;
extern CCLCMsg_HltvReplayDefaultTypeInternal _CCLCMsg_HltvReplay_default_instance_;
class CCLCMsg_ListenEvents;
struct CCLCMsg_ListenEventsDefaultTypeInternal;
extern CCLCMsg_ListenEventsDefaultTypeInternal _CCLCMsg_ListenEvents_default_instance_;
class CCLCMsg_LoadingProgress;
struct CCLCMsg_LoadingProgressDefaultTypeInternal;
extern CCLCMsg_LoadingProgressDefaultTypeInternal _CCLCMsg_LoadingProgress_default_instance_;
class CCLCMsg_Move;
struct CCLCMsg_MoveDefaultTypeInternal;
extern CCLCMsg_MoveDefaultTypeInternal _CCLCMsg_Move_default_instance_;
class CCLCMsg_RconServerDetails;
struct CCLCMsg_RconServerDetailsDefaultTypeInternal;
extern CCLCMsg_RconServerDetailsDefaultTypeInternal _CCLCMsg_RconServerDetails_default_instance_;
class CCLCMsg_RequestPause;
struct CCLCMsg_RequestPauseDefaultTypeInternal;
extern CCLCMsg_RequestPauseDefaultTypeInternal _CCLCMsg_RequestPause_default_instance_;
class CCLCMsg_RespondCvarValue;
struct CCLCMsg_RespondCvarValueDefaultTypeInternal;
extern CCLCMsg_RespondCvarValueDefaultTypeInternal _CCLCMsg_RespondCvarValue_default_instance_;
class CCLCMsg_ServerStatus;
struct CCLCMsg_ServerStatusDefaultTypeInternal;
extern CCLCMsg_ServerStatusDefaultTypeInternal _CCLCMsg_ServerStatus_default_instance_;
class CCLCMsg_SplitPlayerConnect;
struct CCLCMsg_SplitPlayerConnectDefaultTypeInternal;
extern CCLCMsg_SplitPlayerConnectDefaultTypeInternal _CCLCMsg_SplitPlayerConnect_default_instance_;
class CCLCMsg_SplitPlayerDisconnect;
struct CCLCMsg_SplitPlayerDisconnectDefaultTypeInternal;
extern CCLCMsg_SplitPlayerDisconnectDefaultTypeInternal _CCLCMsg_SplitPlayerDisconnect_default_instance_;
class CCLCMsg_VoiceData;
struct CCLCMsg_VoiceDataDefaultTypeInternal;
extern CCLCMsg_VoiceDataDefaultTypeInternal _CCLCMsg_VoiceData_default_instance_;
class CMsgIPCAddress;
struct CMsgIPCAddressDefaultTypeInternal;
extern CMsgIPCAddressDefaultTypeInternal _CMsgIPCAddress_default_instance_;
class CMsgServerNetworkStats;
struct CMsgServerNetworkStatsDefaultTypeInternal;
extern CMsgServerNetworkStatsDefaultTypeInternal _CMsgServerNetworkStats_default_instance_;
class CMsgServerNetworkStats_Player;
struct CMsgServerNetworkStats_PlayerDefaultTypeInternal;
extern CMsgServerNetworkStats_PlayerDefaultTypeInternal _CMsgServerNetworkStats_Player_default_instance_;
class CMsgServerNetworkStats_Port;
struct CMsgServerNetworkStats_PortDefaultTypeInternal;
extern CMsgServerNetworkStats_PortDefaultTypeInternal _CMsgServerNetworkStats_Port_default_instance_;
class CMsgServerPeer;
struct CMsgServerPeerDefaultTypeInternal;
extern CMsgServerPeerDefaultTypeInternal _CMsgServerPeer_default_instance_;
class CMsgServerUserCmd;
struct CMsgServerUserCmdDefaultTypeInternal;
extern CMsgServerUserCmdDefaultTypeInternal _CMsgServerUserCmd_default_instance_;
class CMsgVoiceAudio;
struct CMsgVoiceAudioDefaultTypeInternal;
extern CMsgVoiceAudioDefaultTypeInternal _CMsgVoiceAudio_default_instance_;
class CSVCMsg_BSPDecal;
struct CSVCMsg_BSPDecalDefaultTypeInternal;
extern CSVCMsg_BSPDecalDefaultTypeInternal _CSVCMsg_BSPDecal_default_instance_;
class CSVCMsg_Broadcast_Command;
struct CSVCMsg_Broadcast_CommandDefaultTypeInternal;
extern CSVCMsg_Broadcast_CommandDefaultTypeInternal _CSVCMsg_Broadcast_Command_default_instance_;
class CSVCMsg_ClassInfo;
struct CSVCMsg_ClassInfoDefaultTypeInternal;
extern CSVCMsg_ClassInfoDefaultTypeInternal _CSVCMsg_ClassInfo_default_instance_;
class CSVCMsg_ClassInfo_class_t;
struct CSVCMsg_ClassInfo_class_tDefaultTypeInternal;
extern CSVCMsg_ClassInfo_class_tDefaultTypeInternal _CSVCMsg_ClassInfo_class_t_default_instance_;
class CSVCMsg_ClearAllStringTables;
struct CSVCMsg_ClearAllStringTablesDefaultTypeInternal;
extern CSVCMsg_ClearAllStringTablesDefaultTypeInternal _CSVCMsg_ClearAllStringTables_default_instance_;
class CSVCMsg_CmdKeyValues;
struct CSVCMsg_CmdKeyValuesDefaultTypeInternal;
extern CSVCMsg_CmdKeyValuesDefaultTypeInternal _CSVCMsg_CmdKeyValues_default_instance_;
class CSVCMsg_CreateStringTable;
struct CSVCMsg_CreateStringTableDefaultTypeInternal;
extern CSVCMsg_CreateStringTableDefaultTypeInternal _CSVCMsg_CreateStringTable_default_instance_;
class CSVCMsg_CrosshairAngle;
struct CSVCMsg_CrosshairAngleDefaultTypeInternal;
extern CSVCMsg_CrosshairAngleDefaultTypeInternal _CSVCMsg_CrosshairAngle_default_instance_;
class CSVCMsg_FixAngle;
struct CSVCMsg_FixAngleDefaultTypeInternal;
extern CSVCMsg_FixAngleDefaultTypeInternal _CSVCMsg_FixAngle_default_instance_;
class CSVCMsg_FlattenedSerializer;
struct CSVCMsg_FlattenedSerializerDefaultTypeInternal;
extern CSVCMsg_FlattenedSerializerDefaultTypeInternal _CSVCMsg_FlattenedSerializer_default_instance_;
class CSVCMsg_FullFrameSplit;
struct CSVCMsg_FullFrameSplitDefaultTypeInternal;
extern CSVCMsg_FullFrameSplitDefaultTypeInternal _CSVCMsg_FullFrameSplit_default_instance_;
class CSVCMsg_GameEventList;
struct CSVCMsg_GameEventListDefaultTypeInternal;
extern CSVCMsg_GameEventListDefaultTypeInternal _CSVCMsg_GameEventList_default_instance_;
class CSVCMsg_GameEventList_descriptor_t;
struct CSVCMsg_GameEventList_descriptor_tDefaultTypeInternal;
extern CSVCMsg_GameEventList_descriptor_tDefaultTypeInternal _CSVCMsg_GameEventList_descriptor_t_default_instance_;
class CSVCMsg_GameEventList_key_t;
struct CSVCMsg_GameEventList_key_tDefaultTypeInternal;
extern CSVCMsg_GameEventList_key_tDefaultTypeInternal _CSVCMsg_GameEventList_key_t_default_instance_;
class CSVCMsg_GetCvarValue;
struct CSVCMsg_GetCvarValueDefaultTypeInternal;
extern CSVCMsg_GetCvarValueDefaultTypeInternal _CSVCMsg_GetCvarValue_default_instance_;
class CSVCMsg_HLTVStatus;
struct CSVCMsg_HLTVStatusDefaultTypeInternal;
extern CSVCMsg_HLTVStatusDefaultTypeInternal _CSVCMsg_HLTVStatus_default_instance_;
class CSVCMsg_HltvFixupOperatorStatus;
struct CSVCMsg_HltvFixupOperatorStatusDefaultTypeInternal;
extern CSVCMsg_HltvFixupOperatorStatusDefaultTypeInternal _CSVCMsg_HltvFixupOperatorStatus_default_instance_;
class CSVCMsg_HltvReplay;
struct CSVCMsg_HltvReplayDefaultTypeInternal;
extern CSVCMsg_HltvReplayDefaultTypeInternal _CSVCMsg_HltvReplay_default_instance_;
class CSVCMsg_Menu;
struct CSVCMsg_MenuDefaultTypeInternal;
extern CSVCMsg_MenuDefaultTypeInternal _CSVCMsg_Menu_default_instance_;
class CSVCMsg_NextMsgPredicted;
struct CSVCMsg_NextMsgPredictedDefaultTypeInternal;
extern CSVCMsg_NextMsgPredictedDefaultTypeInternal _CSVCMsg_NextMsgPredicted_default_instance_;
class CSVCMsg_PacketEntities;
struct CSVCMsg_PacketEntitiesDefaultTypeInternal;
extern CSVCMsg_PacketEntitiesDefaultTypeInternal _CSVCMsg_PacketEntities_default_instance_;
class CSVCMsg_PacketEntities_alternate_baseline_t;
struct CSVCMsg_PacketEntities_alternate_baseline_tDefaultTypeInternal;
extern CSVCMsg_PacketEntities_alternate_baseline_tDefaultTypeInternal _CSVCMsg_PacketEntities_alternate_baseline_t_default_instance_;
class CSVCMsg_PacketEntities_non_transmitted_entities_t;
struct CSVCMsg_PacketEntities_non_transmitted_entities_tDefaultTypeInternal;
extern CSVCMsg_PacketEntities_non_transmitted_entities_tDefaultTypeInternal _CSVCMsg_PacketEntities_non_transmitted_entities_t_default_instance_;
class CSVCMsg_PacketEntities_outofpvs_entity_updates_t;
struct CSVCMsg_PacketEntities_outofpvs_entity_updates_tDefaultTypeInternal;
extern CSVCMsg_PacketEntities_outofpvs_entity_updates_tDefaultTypeInternal _CSVCMsg_PacketEntities_outofpvs_entity_updates_t_default_instance_;
class CSVCMsg_PacketReliable;
struct CSVCMsg_PacketReliableDefaultTypeInternal;
extern CSVCMsg_PacketReliableDefaultTypeInternal _CSVCMsg_PacketReliable_default_instance_;
class CSVCMsg_PeerList;
struct CSVCMsg_PeerListDefaultTypeInternal;
extern CSVCMsg_PeerListDefaultTypeInternal _CSVCMsg_PeerList_default_instance_;
class CSVCMsg_Prefetch;
struct CSVCMsg_PrefetchDefaultTypeInternal;
extern CSVCMsg_PrefetchDefaultTypeInternal _CSVCMsg_Prefetch_default_instance_;
class CSVCMsg_Print;
struct CSVCMsg_PrintDefaultTypeInternal;
extern CSVCMsg_PrintDefaultTypeInternal _CSVCMsg_Print_default_instance_;
class CSVCMsg_RconServerDetails;
struct CSVCMsg_RconServerDetailsDefaultTypeInternal;
extern CSVCMsg_RconServerDetailsDefaultTypeInternal _CSVCMsg_RconServerDetails_default_instance_;
class CSVCMsg_SendTable;
struct CSVCMsg_SendTableDefaultTypeInternal;
extern CSVCMsg_SendTableDefaultTypeInternal _CSVCMsg_SendTable_default_instance_;
class CSVCMsg_SendTable_sendprop_t;
struct CSVCMsg_SendTable_sendprop_tDefaultTypeInternal;
extern CSVCMsg_SendTable_sendprop_tDefaultTypeInternal _CSVCMsg_SendTable_sendprop_t_default_instance_;
class CSVCMsg_ServerInfo;
struct CSVCMsg_ServerInfoDefaultTypeInternal;
extern CSVCMsg_ServerInfoDefaultTypeInternal _CSVCMsg_ServerInfo_default_instance_;
class CSVCMsg_ServerSteamID;
struct CSVCMsg_ServerSteamIDDefaultTypeInternal;
extern CSVCMsg_ServerSteamIDDefaultTypeInternal _CSVCMsg_ServerSteamID_default_instance_;
class CSVCMsg_SetPause;
struct CSVCMsg_SetPauseDefaultTypeInternal;
extern CSVCMsg_SetPauseDefaultTypeInternal _CSVCMsg_SetPause_default_instance_;
class CSVCMsg_SetView;
struct CSVCMsg_SetViewDefaultTypeInternal;
extern CSVCMsg_SetViewDefaultTypeInternal _CSVCMsg_SetView_default_instance_;
class CSVCMsg_Sounds;
struct CSVCMsg_SoundsDefaultTypeInternal;
extern CSVCMsg_SoundsDefaultTypeInternal _CSVCMsg_Sounds_default_instance_;
class CSVCMsg_Sounds_sounddata_t;
struct CSVCMsg_Sounds_sounddata_tDefaultTypeInternal;
extern CSVCMsg_Sounds_sounddata_tDefaultTypeInternal _CSVCMsg_Sounds_sounddata_t_default_instance_;
class CSVCMsg_SplitScreen;
struct CSVCMsg_SplitScreenDefaultTypeInternal;
extern CSVCMsg_SplitScreenDefaultTypeInternal _CSVCMsg_SplitScreen_default_instance_;
class CSVCMsg_StopSound;
struct CSVCMsg_StopSoundDefaultTypeInternal;
extern CSVCMsg_StopSoundDefaultTypeInternal _CSVCMsg_StopSound_default_instance_;
class CSVCMsg_TempEntities;
struct CSVCMsg_TempEntitiesDefaultTypeInternal;
extern CSVCMsg_TempEntitiesDefaultTypeInternal _CSVCMsg_TempEntities_default_instance_;
class CSVCMsg_UpdateStringTable;
struct CSVCMsg_UpdateStringTableDefaultTypeInternal;
extern CSVCMsg_UpdateStringTableDefaultTypeInternal _CSVCMsg_UpdateStringTable_default_instance_;
class CSVCMsg_UserCommands;
struct CSVCMsg_UserCommandsDefaultTypeInternal;
extern CSVCMsg_UserCommandsDefaultTypeInternal _CSVCMsg_UserCommands_default_instance_;
class CSVCMsg_UserMessage;
struct CSVCMsg_UserMessageDefaultTypeInternal;
extern CSVCMsg_UserMessageDefaultTypeInternal _CSVCMsg_UserMessage_default_instance_;
class CSVCMsg_VoiceData;
struct CSVCMsg_VoiceDataDefaultTypeInternal;
extern CSVCMsg_VoiceDataDefaultTypeInternal _CSVCMsg_VoiceData_default_instance_;
class CSVCMsg_VoiceInit;
struct CSVCMsg_VoiceInitDefaultTypeInternal;
extern CSVCMsg_VoiceInitDefaultTypeInternal _CSVCMsg_VoiceInit_default_instance_;
class ProtoFlattenedSerializerField_t;
struct ProtoFlattenedSerializerField_tDefaultTypeInternal;
extern ProtoFlattenedSerializerField_tDefaultTypeInternal _ProtoFlattenedSerializerField_t_default_instance_;
class ProtoFlattenedSerializerField_t_polymorphic_field_t;
struct ProtoFlattenedSerializerField_t_polymorphic_field_tDefaultTypeInternal;
extern ProtoFlattenedSerializerField_t_polymorphic_field_tDefaultTypeInternal _ProtoFlattenedSerializerField_t_polymorphic_field_t_default_instance_;
class ProtoFlattenedSerializer_t;
struct ProtoFlattenedSerializer_tDefaultTypeInternal;
extern ProtoFlattenedSerializer_tDefaultTypeInternal _ProtoFlattenedSerializer_t_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::CBidirMsg_PredictionEvent* Arena::CreateMaybeMessage<::CBidirMsg_PredictionEvent>(Arena*);
template<> ::CBidirMsg_RebroadcastGameEvent* Arena::CreateMaybeMessage<::CBidirMsg_RebroadcastGameEvent>(Arena*);
template<> ::CBidirMsg_RebroadcastSource* Arena::CreateMaybeMessage<::CBidirMsg_RebroadcastSource>(Arena*);
template<> ::CCLCMsg_BaselineAck* Arena::CreateMaybeMessage<::CCLCMsg_BaselineAck>(Arena*);
template<> ::CCLCMsg_ClientInfo* Arena::CreateMaybeMessage<::CCLCMsg_ClientInfo>(Arena*);
template<> ::CCLCMsg_CmdKeyValues* Arena::CreateMaybeMessage<::CCLCMsg_CmdKeyValues>(Arena*);
template<> ::CCLCMsg_Diagnostic* Arena::CreateMaybeMessage<::CCLCMsg_Diagnostic>(Arena*);
template<> ::CCLCMsg_HltvFixupOperatorTick* Arena::CreateMaybeMessage<::CCLCMsg_HltvFixupOperatorTick>(Arena*);
template<> ::CCLCMsg_HltvReplay* Arena::CreateMaybeMessage<::CCLCMsg_HltvReplay>(Arena*);
template<> ::CCLCMsg_ListenEvents* Arena::CreateMaybeMessage<::CCLCMsg_ListenEvents>(Arena*);
template<> ::CCLCMsg_LoadingProgress* Arena::CreateMaybeMessage<::CCLCMsg_LoadingProgress>(Arena*);
template<> ::CCLCMsg_Move* Arena::CreateMaybeMessage<::CCLCMsg_Move>(Arena*);
template<> ::CCLCMsg_RconServerDetails* Arena::CreateMaybeMessage<::CCLCMsg_RconServerDetails>(Arena*);
template<> ::CCLCMsg_RequestPause* Arena::CreateMaybeMessage<::CCLCMsg_RequestPause>(Arena*);
template<> ::CCLCMsg_RespondCvarValue* Arena::CreateMaybeMessage<::CCLCMsg_RespondCvarValue>(Arena*);
template<> ::CCLCMsg_ServerStatus* Arena::CreateMaybeMessage<::CCLCMsg_ServerStatus>(Arena*);
template<> ::CCLCMsg_SplitPlayerConnect* Arena::CreateMaybeMessage<::CCLCMsg_SplitPlayerConnect>(Arena*);
template<> ::CCLCMsg_SplitPlayerDisconnect* Arena::CreateMaybeMessage<::CCLCMsg_SplitPlayerDisconnect>(Arena*);
template<> ::CCLCMsg_VoiceData* Arena::CreateMaybeMessage<::CCLCMsg_VoiceData>(Arena*);
template<> ::CMsgIPCAddress* Arena::CreateMaybeMessage<::CMsgIPCAddress>(Arena*);
template<> ::CMsgServerNetworkStats* Arena::CreateMaybeMessage<::CMsgServerNetworkStats>(Arena*);
template<> ::CMsgServerNetworkStats_Player* Arena::CreateMaybeMessage<::CMsgServerNetworkStats_Player>(Arena*);
template<> ::CMsgServerNetworkStats_Port* Arena::CreateMaybeMessage<::CMsgServerNetworkStats_Port>(Arena*);
template<> ::CMsgServerPeer* Arena::CreateMaybeMessage<::CMsgServerPeer>(Arena*);
template<> ::CMsgServerUserCmd* Arena::CreateMaybeMessage<::CMsgServerUserCmd>(Arena*);
template<> ::CMsgVoiceAudio* Arena::CreateMaybeMessage<::CMsgVoiceAudio>(Arena*);
template<> ::CSVCMsg_BSPDecal* Arena::CreateMaybeMessage<::CSVCMsg_BSPDecal>(Arena*);
template<> ::CSVCMsg_Broadcast_Command* Arena::CreateMaybeMessage<::CSVCMsg_Broadcast_Command>(Arena*);
template<> ::CSVCMsg_ClassInfo* Arena::CreateMaybeMessage<::CSVCMsg_ClassInfo>(Arena*);
template<> ::CSVCMsg_ClassInfo_class_t* Arena::CreateMaybeMessage<::CSVCMsg_ClassInfo_class_t>(Arena*);
template<> ::CSVCMsg_ClearAllStringTables* Arena::CreateMaybeMessage<::CSVCMsg_ClearAllStringTables>(Arena*);
template<> ::CSVCMsg_CmdKeyValues* Arena::CreateMaybeMessage<::CSVCMsg_CmdKeyValues>(Arena*);
template<> ::CSVCMsg_CreateStringTable* Arena::CreateMaybeMessage<::CSVCMsg_CreateStringTable>(Arena*);
template<> ::CSVCMsg_CrosshairAngle* Arena::CreateMaybeMessage<::CSVCMsg_CrosshairAngle>(Arena*);
template<> ::CSVCMsg_FixAngle* Arena::CreateMaybeMessage<::CSVCMsg_FixAngle>(Arena*);
template<> ::CSVCMsg_FlattenedSerializer* Arena::CreateMaybeMessage<::CSVCMsg_FlattenedSerializer>(Arena*);
template<> ::CSVCMsg_FullFrameSplit* Arena::CreateMaybeMessage<::CSVCMsg_FullFrameSplit>(Arena*);
template<> ::CSVCMsg_GameEventList* Arena::CreateMaybeMessage<::CSVCMsg_GameEventList>(Arena*);
template<> ::CSVCMsg_GameEventList_descriptor_t* Arena::CreateMaybeMessage<::CSVCMsg_GameEventList_descriptor_t>(Arena*);
template<> ::CSVCMsg_GameEventList_key_t* Arena::CreateMaybeMessage<::CSVCMsg_GameEventList_key_t>(Arena*);
template<> ::CSVCMsg_GetCvarValue* Arena::CreateMaybeMessage<::CSVCMsg_GetCvarValue>(Arena*);
template<> ::CSVCMsg_HLTVStatus* Arena::CreateMaybeMessage<::CSVCMsg_HLTVStatus>(Arena*);
template<> ::CSVCMsg_HltvFixupOperatorStatus* Arena::CreateMaybeMessage<::CSVCMsg_HltvFixupOperatorStatus>(Arena*);
template<> ::CSVCMsg_HltvReplay* Arena::CreateMaybeMessage<::CSVCMsg_HltvReplay>(Arena*);
template<> ::CSVCMsg_Menu* Arena::CreateMaybeMessage<::CSVCMsg_Menu>(Arena*);
template<> ::CSVCMsg_NextMsgPredicted* Arena::CreateMaybeMessage<::CSVCMsg_NextMsgPredicted>(Arena*);
template<> ::CSVCMsg_PacketEntities* Arena::CreateMaybeMessage<::CSVCMsg_PacketEntities>(Arena*);
template<> ::CSVCMsg_PacketEntities_alternate_baseline_t* Arena::CreateMaybeMessage<::CSVCMsg_PacketEntities_alternate_baseline_t>(Arena*);
template<> ::CSVCMsg_PacketEntities_non_transmitted_entities_t* Arena::CreateMaybeMessage<::CSVCMsg_PacketEntities_non_transmitted_entities_t>(Arena*);
template<> ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* Arena::CreateMaybeMessage<::CSVCMsg_PacketEntities_outofpvs_entity_updates_t>(Arena*);
template<> ::CSVCMsg_PacketReliable* Arena::CreateMaybeMessage<::CSVCMsg_PacketReliable>(Arena*);
template<> ::CSVCMsg_PeerList* Arena::CreateMaybeMessage<::CSVCMsg_PeerList>(Arena*);
template<> ::CSVCMsg_Prefetch* Arena::CreateMaybeMessage<::CSVCMsg_Prefetch>(Arena*);
template<> ::CSVCMsg_Print* Arena::CreateMaybeMessage<::CSVCMsg_Print>(Arena*);
template<> ::CSVCMsg_RconServerDetails* Arena::CreateMaybeMessage<::CSVCMsg_RconServerDetails>(Arena*);
template<> ::CSVCMsg_SendTable* Arena::CreateMaybeMessage<::CSVCMsg_SendTable>(Arena*);
template<> ::CSVCMsg_SendTable_sendprop_t* Arena::CreateMaybeMessage<::CSVCMsg_SendTable_sendprop_t>(Arena*);
template<> ::CSVCMsg_ServerInfo* Arena::CreateMaybeMessage<::CSVCMsg_ServerInfo>(Arena*);
template<> ::CSVCMsg_ServerSteamID* Arena::CreateMaybeMessage<::CSVCMsg_ServerSteamID>(Arena*);
template<> ::CSVCMsg_SetPause* Arena::CreateMaybeMessage<::CSVCMsg_SetPause>(Arena*);
template<> ::CSVCMsg_SetView* Arena::CreateMaybeMessage<::CSVCMsg_SetView>(Arena*);
template<> ::CSVCMsg_Sounds* Arena::CreateMaybeMessage<::CSVCMsg_Sounds>(Arena*);
template<> ::CSVCMsg_Sounds_sounddata_t* Arena::CreateMaybeMessage<::CSVCMsg_Sounds_sounddata_t>(Arena*);
template<> ::CSVCMsg_SplitScreen* Arena::CreateMaybeMessage<::CSVCMsg_SplitScreen>(Arena*);
template<> ::CSVCMsg_StopSound* Arena::CreateMaybeMessage<::CSVCMsg_StopSound>(Arena*);
template<> ::CSVCMsg_TempEntities* Arena::CreateMaybeMessage<::CSVCMsg_TempEntities>(Arena*);
template<> ::CSVCMsg_UpdateStringTable* Arena::CreateMaybeMessage<::CSVCMsg_UpdateStringTable>(Arena*);
template<> ::CSVCMsg_UserCommands* Arena::CreateMaybeMessage<::CSVCMsg_UserCommands>(Arena*);
template<> ::CSVCMsg_UserMessage* Arena::CreateMaybeMessage<::CSVCMsg_UserMessage>(Arena*);
template<> ::CSVCMsg_VoiceData* Arena::CreateMaybeMessage<::CSVCMsg_VoiceData>(Arena*);
template<> ::CSVCMsg_VoiceInit* Arena::CreateMaybeMessage<::CSVCMsg_VoiceInit>(Arena*);
template<> ::ProtoFlattenedSerializerField_t* Arena::CreateMaybeMessage<::ProtoFlattenedSerializerField_t>(Arena*);
template<> ::ProtoFlattenedSerializerField_t_polymorphic_field_t* Arena::CreateMaybeMessage<::ProtoFlattenedSerializerField_t_polymorphic_field_t>(Arena*);
template<> ::ProtoFlattenedSerializer_t* Arena::CreateMaybeMessage<::ProtoFlattenedSerializer_t>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum CBidirMsg_PredictionEvent_ESyncType : int {
  CBidirMsg_PredictionEvent_ESyncType_ST_Tick = 0,
  CBidirMsg_PredictionEvent_ESyncType_ST_UserCmdNum = 1
};
bool CBidirMsg_PredictionEvent_ESyncType_IsValid(int value);
constexpr CBidirMsg_PredictionEvent_ESyncType CBidirMsg_PredictionEvent_ESyncType_ESyncType_MIN = CBidirMsg_PredictionEvent_ESyncType_ST_Tick;
constexpr CBidirMsg_PredictionEvent_ESyncType CBidirMsg_PredictionEvent_ESyncType_ESyncType_MAX = CBidirMsg_PredictionEvent_ESyncType_ST_UserCmdNum;
constexpr int CBidirMsg_PredictionEvent_ESyncType_ESyncType_ARRAYSIZE = CBidirMsg_PredictionEvent_ESyncType_ESyncType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CBidirMsg_PredictionEvent_ESyncType_descriptor();
template<typename T>
inline const std::string& CBidirMsg_PredictionEvent_ESyncType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CBidirMsg_PredictionEvent_ESyncType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CBidirMsg_PredictionEvent_ESyncType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CBidirMsg_PredictionEvent_ESyncType_descriptor(), enum_t_value);
}
inline bool CBidirMsg_PredictionEvent_ESyncType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CBidirMsg_PredictionEvent_ESyncType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CBidirMsg_PredictionEvent_ESyncType>(
    CBidirMsg_PredictionEvent_ESyncType_descriptor(), name, value);
}
enum CLC_Messages : int {
  clc_ClientInfo = 20,
  clc_Move = 21,
  clc_VoiceData = 22,
  clc_BaselineAck = 23,
  clc_RespondCvarValue = 25,
  clc_LoadingProgress = 27,
  clc_SplitPlayerConnect = 28,
  clc_SplitPlayerDisconnect = 30,
  clc_ServerStatus = 31,
  clc_RequestPause = 33,
  clc_CmdKeyValues = 34,
  clc_RconServerDetails = 35,
  clc_HltvReplay = 36,
  clc_Diagnostic = 37
};
bool CLC_Messages_IsValid(int value);
constexpr CLC_Messages CLC_Messages_MIN = clc_ClientInfo;
constexpr CLC_Messages CLC_Messages_MAX = clc_Diagnostic;
constexpr int CLC_Messages_ARRAYSIZE = CLC_Messages_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CLC_Messages_descriptor();
template<typename T>
inline const std::string& CLC_Messages_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CLC_Messages>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CLC_Messages_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CLC_Messages_descriptor(), enum_t_value);
}
inline bool CLC_Messages_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CLC_Messages* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CLC_Messages>(
    CLC_Messages_descriptor(), name, value);
}
enum SVC_Messages : int {
  svc_ServerInfo = 40,
  svc_FlattenedSerializer = 41,
  svc_ClassInfo = 42,
  svc_SetPause = 43,
  svc_CreateStringTable = 44,
  svc_UpdateStringTable = 45,
  svc_VoiceInit = 46,
  svc_VoiceData = 47,
  svc_Print = 48,
  svc_Sounds = 49,
  svc_SetView = 50,
  svc_ClearAllStringTables = 51,
  svc_CmdKeyValues = 52,
  svc_BSPDecal = 53,
  svc_SplitScreen = 54,
  svc_PacketEntities = 55,
  svc_Prefetch = 56,
  svc_Menu = 57,
  svc_GetCvarValue = 58,
  svc_StopSound = 59,
  svc_PeerList = 60,
  svc_PacketReliable = 61,
  svc_HLTVStatus = 62,
  svc_ServerSteamID = 63,
  svc_FullFrameSplit = 70,
  svc_RconServerDetails = 71,
  svc_UserMessage = 72,
  svc_Broadcast_Command = 74,
  svc_HltvFixupOperatorStatus = 75,
  svc_UserCmds = 76,
  svc_NextMsgPredicted = 77
};
bool SVC_Messages_IsValid(int value);
constexpr SVC_Messages SVC_Messages_MIN = svc_ServerInfo;
constexpr SVC_Messages SVC_Messages_MAX = svc_NextMsgPredicted;
constexpr int SVC_Messages_ARRAYSIZE = SVC_Messages_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SVC_Messages_descriptor();
template<typename T>
inline const std::string& SVC_Messages_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SVC_Messages>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SVC_Messages_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SVC_Messages_descriptor(), enum_t_value);
}
inline bool SVC_Messages_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SVC_Messages* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SVC_Messages>(
    SVC_Messages_descriptor(), name, value);
}
enum VoiceDataFormat_t : int {
  VOICEDATA_FORMAT_STEAM = 0,
  VOICEDATA_FORMAT_ENGINE = 1,
  VOICEDATA_FORMAT_OPUS = 2
};
bool VoiceDataFormat_t_IsValid(int value);
constexpr VoiceDataFormat_t VoiceDataFormat_t_MIN = VOICEDATA_FORMAT_STEAM;
constexpr VoiceDataFormat_t VoiceDataFormat_t_MAX = VOICEDATA_FORMAT_OPUS;
constexpr int VoiceDataFormat_t_ARRAYSIZE = VoiceDataFormat_t_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* VoiceDataFormat_t_descriptor();
template<typename T>
inline const std::string& VoiceDataFormat_t_Name(T enum_t_value) {
  static_assert(::std::is_same<T, VoiceDataFormat_t>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function VoiceDataFormat_t_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    VoiceDataFormat_t_descriptor(), enum_t_value);
}
inline bool VoiceDataFormat_t_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VoiceDataFormat_t* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<VoiceDataFormat_t>(
    VoiceDataFormat_t_descriptor(), name, value);
}
enum RequestPause_t : int {
  RP_PAUSE = 0,
  RP_UNPAUSE = 1,
  RP_TOGGLEPAUSE = 2
};
bool RequestPause_t_IsValid(int value);
constexpr RequestPause_t RequestPause_t_MIN = RP_PAUSE;
constexpr RequestPause_t RequestPause_t_MAX = RP_TOGGLEPAUSE;
constexpr int RequestPause_t_ARRAYSIZE = RequestPause_t_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RequestPause_t_descriptor();
template<typename T>
inline const std::string& RequestPause_t_Name(T enum_t_value) {
  static_assert(::std::is_same<T, RequestPause_t>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function RequestPause_t_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    RequestPause_t_descriptor(), enum_t_value);
}
inline bool RequestPause_t_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RequestPause_t* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RequestPause_t>(
    RequestPause_t_descriptor(), name, value);
}
enum PrefetchType : int {
  PFT_SOUND = 0
};
bool PrefetchType_IsValid(int value);
constexpr PrefetchType PrefetchType_MIN = PFT_SOUND;
constexpr PrefetchType PrefetchType_MAX = PFT_SOUND;
constexpr int PrefetchType_ARRAYSIZE = PrefetchType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PrefetchType_descriptor();
template<typename T>
inline const std::string& PrefetchType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PrefetchType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PrefetchType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PrefetchType_descriptor(), enum_t_value);
}
inline bool PrefetchType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PrefetchType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PrefetchType>(
    PrefetchType_descriptor(), name, value);
}
enum ESplitScreenMessageType : int {
  MSG_SPLITSCREEN_ADDUSER = 0,
  MSG_SPLITSCREEN_REMOVEUSER = 1
};
bool ESplitScreenMessageType_IsValid(int value);
constexpr ESplitScreenMessageType ESplitScreenMessageType_MIN = MSG_SPLITSCREEN_ADDUSER;
constexpr ESplitScreenMessageType ESplitScreenMessageType_MAX = MSG_SPLITSCREEN_REMOVEUSER;
constexpr int ESplitScreenMessageType_ARRAYSIZE = ESplitScreenMessageType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ESplitScreenMessageType_descriptor();
template<typename T>
inline const std::string& ESplitScreenMessageType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ESplitScreenMessageType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ESplitScreenMessageType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ESplitScreenMessageType_descriptor(), enum_t_value);
}
inline bool ESplitScreenMessageType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ESplitScreenMessageType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ESplitScreenMessageType>(
    ESplitScreenMessageType_descriptor(), name, value);
}
enum EQueryCvarValueStatus : int {
  eQueryCvarValueStatus_ValueIntact = 0,
  eQueryCvarValueStatus_CvarNotFound = 1,
  eQueryCvarValueStatus_NotACvar = 2,
  eQueryCvarValueStatus_CvarProtected = 3
};
bool EQueryCvarValueStatus_IsValid(int value);
constexpr EQueryCvarValueStatus EQueryCvarValueStatus_MIN = eQueryCvarValueStatus_ValueIntact;
constexpr EQueryCvarValueStatus EQueryCvarValueStatus_MAX = eQueryCvarValueStatus_CvarProtected;
constexpr int EQueryCvarValueStatus_ARRAYSIZE = EQueryCvarValueStatus_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* EQueryCvarValueStatus_descriptor();
template<typename T>
inline const std::string& EQueryCvarValueStatus_Name(T enum_t_value) {
  static_assert(::std::is_same<T, EQueryCvarValueStatus>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function EQueryCvarValueStatus_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    EQueryCvarValueStatus_descriptor(), enum_t_value);
}
inline bool EQueryCvarValueStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EQueryCvarValueStatus* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<EQueryCvarValueStatus>(
    EQueryCvarValueStatus_descriptor(), name, value);
}
enum DIALOG_TYPE : int {
  DIALOG_MSG = 0,
  DIALOG_MENU = 1,
  DIALOG_TEXT = 2,
  DIALOG_ENTRY = 3,
  DIALOG_ASKCONNECT = 4
};
bool DIALOG_TYPE_IsValid(int value);
constexpr DIALOG_TYPE DIALOG_TYPE_MIN = DIALOG_MSG;
constexpr DIALOG_TYPE DIALOG_TYPE_MAX = DIALOG_ASKCONNECT;
constexpr int DIALOG_TYPE_ARRAYSIZE = DIALOG_TYPE_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DIALOG_TYPE_descriptor();
template<typename T>
inline const std::string& DIALOG_TYPE_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DIALOG_TYPE>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DIALOG_TYPE_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DIALOG_TYPE_descriptor(), enum_t_value);
}
inline bool DIALOG_TYPE_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DIALOG_TYPE* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DIALOG_TYPE>(
    DIALOG_TYPE_descriptor(), name, value);
}
enum SVC_Messages_LowFrequency : int {
  svc_dummy = 600
};
bool SVC_Messages_LowFrequency_IsValid(int value);
constexpr SVC_Messages_LowFrequency SVC_Messages_LowFrequency_MIN = svc_dummy;
constexpr SVC_Messages_LowFrequency SVC_Messages_LowFrequency_MAX = svc_dummy;
constexpr int SVC_Messages_LowFrequency_ARRAYSIZE = SVC_Messages_LowFrequency_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SVC_Messages_LowFrequency_descriptor();
template<typename T>
inline const std::string& SVC_Messages_LowFrequency_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SVC_Messages_LowFrequency>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SVC_Messages_LowFrequency_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SVC_Messages_LowFrequency_descriptor(), enum_t_value);
}
inline bool SVC_Messages_LowFrequency_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SVC_Messages_LowFrequency* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SVC_Messages_LowFrequency>(
    SVC_Messages_LowFrequency_descriptor(), name, value);
}
enum Bidirectional_Messages : int {
  bi_RebroadcastGameEvent = 16,
  bi_RebroadcastSource = 17,
  bi_GameEvent = 18,
  bi_PredictionEvent = 19
};
bool Bidirectional_Messages_IsValid(int value);
constexpr Bidirectional_Messages Bidirectional_Messages_MIN = bi_RebroadcastGameEvent;
constexpr Bidirectional_Messages Bidirectional_Messages_MAX = bi_PredictionEvent;
constexpr int Bidirectional_Messages_ARRAYSIZE = Bidirectional_Messages_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Bidirectional_Messages_descriptor();
template<typename T>
inline const std::string& Bidirectional_Messages_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Bidirectional_Messages>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Bidirectional_Messages_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Bidirectional_Messages_descriptor(), enum_t_value);
}
inline bool Bidirectional_Messages_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Bidirectional_Messages* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Bidirectional_Messages>(
    Bidirectional_Messages_descriptor(), name, value);
}
enum Bidirectional_Messages_LowFrequency : int {
  bi_RelayInfo = 700,
  bi_RelayPacket = 701
};
bool Bidirectional_Messages_LowFrequency_IsValid(int value);
constexpr Bidirectional_Messages_LowFrequency Bidirectional_Messages_LowFrequency_MIN = bi_RelayInfo;
constexpr Bidirectional_Messages_LowFrequency Bidirectional_Messages_LowFrequency_MAX = bi_RelayPacket;
constexpr int Bidirectional_Messages_LowFrequency_ARRAYSIZE = Bidirectional_Messages_LowFrequency_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Bidirectional_Messages_LowFrequency_descriptor();
template<typename T>
inline const std::string& Bidirectional_Messages_LowFrequency_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Bidirectional_Messages_LowFrequency>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Bidirectional_Messages_LowFrequency_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Bidirectional_Messages_LowFrequency_descriptor(), enum_t_value);
}
inline bool Bidirectional_Messages_LowFrequency_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Bidirectional_Messages_LowFrequency* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Bidirectional_Messages_LowFrequency>(
    Bidirectional_Messages_LowFrequency_descriptor(), name, value);
}
enum ReplayEventType_t : int {
  REPLAY_EVENT_CANCEL = 0,
  REPLAY_EVENT_DEATH = 1,
  REPLAY_EVENT_GENERIC = 2,
  REPLAY_EVENT_STUCK_NEED_FULL_UPDATE = 3,
  REPLAY_EVENT_VICTORY = 4
};
bool ReplayEventType_t_IsValid(int value);
constexpr ReplayEventType_t ReplayEventType_t_MIN = REPLAY_EVENT_CANCEL;
constexpr ReplayEventType_t ReplayEventType_t_MAX = REPLAY_EVENT_VICTORY;
constexpr int ReplayEventType_t_ARRAYSIZE = ReplayEventType_t_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReplayEventType_t_descriptor();
template<typename T>
inline const std::string& ReplayEventType_t_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ReplayEventType_t>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ReplayEventType_t_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ReplayEventType_t_descriptor(), enum_t_value);
}
inline bool ReplayEventType_t_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReplayEventType_t* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ReplayEventType_t>(
    ReplayEventType_t_descriptor(), name, value);
}
// ===================================================================

class CCLCMsg_ClientInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_ClientInfo) */ {
 public:
  inline CCLCMsg_ClientInfo() : CCLCMsg_ClientInfo(nullptr) {}
  ~CCLCMsg_ClientInfo() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_ClientInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_ClientInfo(const CCLCMsg_ClientInfo& from);
  CCLCMsg_ClientInfo(CCLCMsg_ClientInfo&& from) noexcept
    : CCLCMsg_ClientInfo() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_ClientInfo& operator=(const CCLCMsg_ClientInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_ClientInfo& operator=(CCLCMsg_ClientInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_ClientInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_ClientInfo* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_ClientInfo*>(
               &_CCLCMsg_ClientInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(CCLCMsg_ClientInfo& a, CCLCMsg_ClientInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_ClientInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_ClientInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_ClientInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_ClientInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_ClientInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_ClientInfo& from) {
    CCLCMsg_ClientInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_ClientInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_ClientInfo";
  }
  protected:
  explicit CCLCMsg_ClientInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFriendsNameFieldNumber = 6,
    kSendTableCrcFieldNumber = 1,
    kServerCountFieldNumber = 2,
    kIsHltvFieldNumber = 3,
    kFriendsIdFieldNumber = 5,
  };
  // optional string friends_name = 6;
  bool has_friends_name() const;
  private:
  bool _internal_has_friends_name() const;
  public:
  void clear_friends_name();
  const std::string& friends_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_friends_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_friends_name();
  PROTOBUF_NODISCARD std::string* release_friends_name();
  void set_allocated_friends_name(std::string* friends_name);
  private:
  const std::string& _internal_friends_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_friends_name(const std::string& value);
  std::string* _internal_mutable_friends_name();
  public:

  // optional fixed32 send_table_crc = 1;
  bool has_send_table_crc() const;
  private:
  bool _internal_has_send_table_crc() const;
  public:
  void clear_send_table_crc();
  uint32_t send_table_crc() const;
  void set_send_table_crc(uint32_t value);
  private:
  uint32_t _internal_send_table_crc() const;
  void _internal_set_send_table_crc(uint32_t value);
  public:

  // optional uint32 server_count = 2;
  bool has_server_count() const;
  private:
  bool _internal_has_server_count() const;
  public:
  void clear_server_count();
  uint32_t server_count() const;
  void set_server_count(uint32_t value);
  private:
  uint32_t _internal_server_count() const;
  void _internal_set_server_count(uint32_t value);
  public:

  // optional bool is_hltv = 3;
  bool has_is_hltv() const;
  private:
  bool _internal_has_is_hltv() const;
  public:
  void clear_is_hltv();
  bool is_hltv() const;
  void set_is_hltv(bool value);
  private:
  bool _internal_is_hltv() const;
  void _internal_set_is_hltv(bool value);
  public:

  // optional uint32 friends_id = 5;
  bool has_friends_id() const;
  private:
  bool _internal_has_friends_id() const;
  public:
  void clear_friends_id();
  uint32_t friends_id() const;
  void set_friends_id(uint32_t value);
  private:
  uint32_t _internal_friends_id() const;
  void _internal_set_friends_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CCLCMsg_ClientInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr friends_name_;
    uint32_t send_table_crc_;
    uint32_t server_count_;
    bool is_hltv_;
    uint32_t friends_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CCLCMsg_Move final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_Move) */ {
 public:
  inline CCLCMsg_Move() : CCLCMsg_Move(nullptr) {}
  ~CCLCMsg_Move() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_Move(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_Move(const CCLCMsg_Move& from);
  CCLCMsg_Move(CCLCMsg_Move&& from) noexcept
    : CCLCMsg_Move() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_Move& operator=(const CCLCMsg_Move& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_Move& operator=(CCLCMsg_Move&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_Move& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_Move* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_Move*>(
               &_CCLCMsg_Move_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(CCLCMsg_Move& a, CCLCMsg_Move& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_Move* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_Move* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_Move* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_Move>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_Move& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_Move& from) {
    CCLCMsg_Move::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_Move* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_Move";
  }
  protected:
  explicit CCLCMsg_Move(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 3,
    kLastCommandNumberFieldNumber = 4,
  };
  // optional bytes data = 3;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // optional uint32 last_command_number = 4;
  bool has_last_command_number() const;
  private:
  bool _internal_has_last_command_number() const;
  public:
  void clear_last_command_number();
  uint32_t last_command_number() const;
  void set_last_command_number(uint32_t value);
  private:
  uint32_t _internal_last_command_number() const;
  void _internal_set_last_command_number(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CCLCMsg_Move)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    uint32_t last_command_number_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgVoiceAudio final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgVoiceAudio) */ {
 public:
  inline CMsgVoiceAudio() : CMsgVoiceAudio(nullptr) {}
  ~CMsgVoiceAudio() override;
  explicit PROTOBUF_CONSTEXPR CMsgVoiceAudio(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgVoiceAudio(const CMsgVoiceAudio& from);
  CMsgVoiceAudio(CMsgVoiceAudio&& from) noexcept
    : CMsgVoiceAudio() {
    *this = ::std::move(from);
  }

  inline CMsgVoiceAudio& operator=(const CMsgVoiceAudio& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgVoiceAudio& operator=(CMsgVoiceAudio&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgVoiceAudio& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgVoiceAudio* internal_default_instance() {
    return reinterpret_cast<const CMsgVoiceAudio*>(
               &_CMsgVoiceAudio_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(CMsgVoiceAudio& a, CMsgVoiceAudio& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgVoiceAudio* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgVoiceAudio* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgVoiceAudio* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgVoiceAudio>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgVoiceAudio& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgVoiceAudio& from) {
    CMsgVoiceAudio::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgVoiceAudio* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgVoiceAudio";
  }
  protected:
  explicit CMsgVoiceAudio(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPacketOffsetsFieldNumber = 8,
    kVoiceDataFieldNumber = 2,
    kFormatFieldNumber = 1,
    kSequenceBytesFieldNumber = 3,
    kSectionNumberFieldNumber = 4,
    kSampleRateFieldNumber = 5,
    kUncompressedSampleOffsetFieldNumber = 6,
    kNumPacketsFieldNumber = 7,
    kVoiceLevelFieldNumber = 9,
  };
  // repeated uint32 packet_offsets = 8 [packed = true];
  int packet_offsets_size() const;
  private:
  int _internal_packet_offsets_size() const;
  public:
  void clear_packet_offsets();
  private:
  uint32_t _internal_packet_offsets(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_packet_offsets() const;
  void _internal_add_packet_offsets(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_packet_offsets();
  public:
  uint32_t packet_offsets(int index) const;
  void set_packet_offsets(int index, uint32_t value);
  void add_packet_offsets(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      packet_offsets() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_packet_offsets();

  // optional bytes voice_data = 2;
  bool has_voice_data() const;
  private:
  bool _internal_has_voice_data() const;
  public:
  void clear_voice_data();
  const std::string& voice_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_voice_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_voice_data();
  PROTOBUF_NODISCARD std::string* release_voice_data();
  void set_allocated_voice_data(std::string* voice_data);
  private:
  const std::string& _internal_voice_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_voice_data(const std::string& value);
  std::string* _internal_mutable_voice_data();
  public:

  // optional .VoiceDataFormat_t format = 1 [default = VOICEDATA_FORMAT_STEAM];
  bool has_format() const;
  private:
  bool _internal_has_format() const;
  public:
  void clear_format();
  ::VoiceDataFormat_t format() const;
  void set_format(::VoiceDataFormat_t value);
  private:
  ::VoiceDataFormat_t _internal_format() const;
  void _internal_set_format(::VoiceDataFormat_t value);
  public:

  // optional int32 sequence_bytes = 3;
  bool has_sequence_bytes() const;
  private:
  bool _internal_has_sequence_bytes() const;
  public:
  void clear_sequence_bytes();
  int32_t sequence_bytes() const;
  void set_sequence_bytes(int32_t value);
  private:
  int32_t _internal_sequence_bytes() const;
  void _internal_set_sequence_bytes(int32_t value);
  public:

  // optional uint32 section_number = 4;
  bool has_section_number() const;
  private:
  bool _internal_has_section_number() const;
  public:
  void clear_section_number();
  uint32_t section_number() const;
  void set_section_number(uint32_t value);
  private:
  uint32_t _internal_section_number() const;
  void _internal_set_section_number(uint32_t value);
  public:

  // optional uint32 sample_rate = 5;
  bool has_sample_rate() const;
  private:
  bool _internal_has_sample_rate() const;
  public:
  void clear_sample_rate();
  uint32_t sample_rate() const;
  void set_sample_rate(uint32_t value);
  private:
  uint32_t _internal_sample_rate() const;
  void _internal_set_sample_rate(uint32_t value);
  public:

  // optional uint32 uncompressed_sample_offset = 6;
  bool has_uncompressed_sample_offset() const;
  private:
  bool _internal_has_uncompressed_sample_offset() const;
  public:
  void clear_uncompressed_sample_offset();
  uint32_t uncompressed_sample_offset() const;
  void set_uncompressed_sample_offset(uint32_t value);
  private:
  uint32_t _internal_uncompressed_sample_offset() const;
  void _internal_set_uncompressed_sample_offset(uint32_t value);
  public:

  // optional uint32 num_packets = 7;
  bool has_num_packets() const;
  private:
  bool _internal_has_num_packets() const;
  public:
  void clear_num_packets();
  uint32_t num_packets() const;
  void set_num_packets(uint32_t value);
  private:
  uint32_t _internal_num_packets() const;
  void _internal_set_num_packets(uint32_t value);
  public:

  // optional float voice_level = 9;
  bool has_voice_level() const;
  private:
  bool _internal_has_voice_level() const;
  public:
  void clear_voice_level();
  float voice_level() const;
  void set_voice_level(float value);
  private:
  float _internal_voice_level() const;
  void _internal_set_voice_level(float value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgVoiceAudio)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > packet_offsets_;
    mutable std::atomic<int> _packet_offsets_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr voice_data_;
    int format_;
    int32_t sequence_bytes_;
    uint32_t section_number_;
    uint32_t sample_rate_;
    uint32_t uncompressed_sample_offset_;
    uint32_t num_packets_;
    float voice_level_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CCLCMsg_VoiceData final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_VoiceData) */ {
 public:
  inline CCLCMsg_VoiceData() : CCLCMsg_VoiceData(nullptr) {}
  ~CCLCMsg_VoiceData() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_VoiceData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_VoiceData(const CCLCMsg_VoiceData& from);
  CCLCMsg_VoiceData(CCLCMsg_VoiceData&& from) noexcept
    : CCLCMsg_VoiceData() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_VoiceData& operator=(const CCLCMsg_VoiceData& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_VoiceData& operator=(CCLCMsg_VoiceData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_VoiceData& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_VoiceData* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_VoiceData*>(
               &_CCLCMsg_VoiceData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(CCLCMsg_VoiceData& a, CCLCMsg_VoiceData& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_VoiceData* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_VoiceData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_VoiceData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_VoiceData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_VoiceData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_VoiceData& from) {
    CCLCMsg_VoiceData::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_VoiceData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_VoiceData";
  }
  protected:
  explicit CCLCMsg_VoiceData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAudioFieldNumber = 1,
    kXuidFieldNumber = 2,
    kTickFieldNumber = 3,
  };
  // optional .CMsgVoiceAudio audio = 1;
  bool has_audio() const;
  private:
  bool _internal_has_audio() const;
  public:
  void clear_audio();
  const ::CMsgVoiceAudio& audio() const;
  PROTOBUF_NODISCARD ::CMsgVoiceAudio* release_audio();
  ::CMsgVoiceAudio* mutable_audio();
  void set_allocated_audio(::CMsgVoiceAudio* audio);
  private:
  const ::CMsgVoiceAudio& _internal_audio() const;
  ::CMsgVoiceAudio* _internal_mutable_audio();
  public:
  void unsafe_arena_set_allocated_audio(
      ::CMsgVoiceAudio* audio);
  ::CMsgVoiceAudio* unsafe_arena_release_audio();

  // optional fixed64 xuid = 2;
  bool has_xuid() const;
  private:
  bool _internal_has_xuid() const;
  public:
  void clear_xuid();
  uint64_t xuid() const;
  void set_xuid(uint64_t value);
  private:
  uint64_t _internal_xuid() const;
  void _internal_set_xuid(uint64_t value);
  public:

  // optional uint32 tick = 3;
  bool has_tick() const;
  private:
  bool _internal_has_tick() const;
  public:
  void clear_tick();
  uint32_t tick() const;
  void set_tick(uint32_t value);
  private:
  uint32_t _internal_tick() const;
  void _internal_set_tick(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CCLCMsg_VoiceData)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::CMsgVoiceAudio* audio_;
    uint64_t xuid_;
    uint32_t tick_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CCLCMsg_BaselineAck final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_BaselineAck) */ {
 public:
  inline CCLCMsg_BaselineAck() : CCLCMsg_BaselineAck(nullptr) {}
  ~CCLCMsg_BaselineAck() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_BaselineAck(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_BaselineAck(const CCLCMsg_BaselineAck& from);
  CCLCMsg_BaselineAck(CCLCMsg_BaselineAck&& from) noexcept
    : CCLCMsg_BaselineAck() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_BaselineAck& operator=(const CCLCMsg_BaselineAck& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_BaselineAck& operator=(CCLCMsg_BaselineAck&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_BaselineAck& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_BaselineAck* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_BaselineAck*>(
               &_CCLCMsg_BaselineAck_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(CCLCMsg_BaselineAck& a, CCLCMsg_BaselineAck& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_BaselineAck* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_BaselineAck* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_BaselineAck* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_BaselineAck>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_BaselineAck& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_BaselineAck& from) {
    CCLCMsg_BaselineAck::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_BaselineAck* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_BaselineAck";
  }
  protected:
  explicit CCLCMsg_BaselineAck(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kBaselineTickFieldNumber = 1,
    kBaselineNrFieldNumber = 2,
  };
  // optional int32 baseline_tick = 1;
  bool has_baseline_tick() const;
  private:
  bool _internal_has_baseline_tick() const;
  public:
  void clear_baseline_tick();
  int32_t baseline_tick() const;
  void set_baseline_tick(int32_t value);
  private:
  int32_t _internal_baseline_tick() const;
  void _internal_set_baseline_tick(int32_t value);
  public:

  // optional int32 baseline_nr = 2;
  bool has_baseline_nr() const;
  private:
  bool _internal_has_baseline_nr() const;
  public:
  void clear_baseline_nr();
  int32_t baseline_nr() const;
  void set_baseline_nr(int32_t value);
  private:
  int32_t _internal_baseline_nr() const;
  void _internal_set_baseline_nr(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CCLCMsg_BaselineAck)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t baseline_tick_;
    int32_t baseline_nr_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CCLCMsg_ListenEvents final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_ListenEvents) */ {
 public:
  inline CCLCMsg_ListenEvents() : CCLCMsg_ListenEvents(nullptr) {}
  ~CCLCMsg_ListenEvents() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_ListenEvents(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_ListenEvents(const CCLCMsg_ListenEvents& from);
  CCLCMsg_ListenEvents(CCLCMsg_ListenEvents&& from) noexcept
    : CCLCMsg_ListenEvents() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_ListenEvents& operator=(const CCLCMsg_ListenEvents& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_ListenEvents& operator=(CCLCMsg_ListenEvents&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_ListenEvents& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_ListenEvents* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_ListenEvents*>(
               &_CCLCMsg_ListenEvents_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(CCLCMsg_ListenEvents& a, CCLCMsg_ListenEvents& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_ListenEvents* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_ListenEvents* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_ListenEvents* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_ListenEvents>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_ListenEvents& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_ListenEvents& from) {
    CCLCMsg_ListenEvents::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_ListenEvents* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_ListenEvents";
  }
  protected:
  explicit CCLCMsg_ListenEvents(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEventMaskFieldNumber = 1,
  };
  // repeated fixed32 event_mask = 1;
  int event_mask_size() const;
  private:
  int _internal_event_mask_size() const;
  public:
  void clear_event_mask();
  private:
  uint32_t _internal_event_mask(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_event_mask() const;
  void _internal_add_event_mask(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_event_mask();
  public:
  uint32_t event_mask(int index) const;
  void set_event_mask(int index, uint32_t value);
  void add_event_mask(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      event_mask() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_event_mask();

  // @@protoc_insertion_point(class_scope:CCLCMsg_ListenEvents)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > event_mask_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CCLCMsg_RespondCvarValue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_RespondCvarValue) */ {
 public:
  inline CCLCMsg_RespondCvarValue() : CCLCMsg_RespondCvarValue(nullptr) {}
  ~CCLCMsg_RespondCvarValue() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_RespondCvarValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_RespondCvarValue(const CCLCMsg_RespondCvarValue& from);
  CCLCMsg_RespondCvarValue(CCLCMsg_RespondCvarValue&& from) noexcept
    : CCLCMsg_RespondCvarValue() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_RespondCvarValue& operator=(const CCLCMsg_RespondCvarValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_RespondCvarValue& operator=(CCLCMsg_RespondCvarValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_RespondCvarValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_RespondCvarValue* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_RespondCvarValue*>(
               &_CCLCMsg_RespondCvarValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(CCLCMsg_RespondCvarValue& a, CCLCMsg_RespondCvarValue& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_RespondCvarValue* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_RespondCvarValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_RespondCvarValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_RespondCvarValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_RespondCvarValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_RespondCvarValue& from) {
    CCLCMsg_RespondCvarValue::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_RespondCvarValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_RespondCvarValue";
  }
  protected:
  explicit CCLCMsg_RespondCvarValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 3,
    kValueFieldNumber = 4,
    kCookieFieldNumber = 1,
    kStatusCodeFieldNumber = 2,
  };
  // optional string name = 3;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // optional string value = 4;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const std::string& value() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_value(ArgT0&& arg0, ArgT... args);
  std::string* mutable_value();
  PROTOBUF_NODISCARD std::string* release_value();
  void set_allocated_value(std::string* value);
  private:
  const std::string& _internal_value() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
  std::string* _internal_mutable_value();
  public:

  // optional int32 cookie = 1;
  bool has_cookie() const;
  private:
  bool _internal_has_cookie() const;
  public:
  void clear_cookie();
  int32_t cookie() const;
  void set_cookie(int32_t value);
  private:
  int32_t _internal_cookie() const;
  void _internal_set_cookie(int32_t value);
  public:

  // optional int32 status_code = 2;
  bool has_status_code() const;
  private:
  bool _internal_has_status_code() const;
  public:
  void clear_status_code();
  int32_t status_code() const;
  void set_status_code(int32_t value);
  private:
  int32_t _internal_status_code() const;
  void _internal_set_status_code(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CCLCMsg_RespondCvarValue)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
    int32_t cookie_;
    int32_t status_code_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CCLCMsg_LoadingProgress final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_LoadingProgress) */ {
 public:
  inline CCLCMsg_LoadingProgress() : CCLCMsg_LoadingProgress(nullptr) {}
  ~CCLCMsg_LoadingProgress() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_LoadingProgress(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_LoadingProgress(const CCLCMsg_LoadingProgress& from);
  CCLCMsg_LoadingProgress(CCLCMsg_LoadingProgress&& from) noexcept
    : CCLCMsg_LoadingProgress() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_LoadingProgress& operator=(const CCLCMsg_LoadingProgress& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_LoadingProgress& operator=(CCLCMsg_LoadingProgress&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_LoadingProgress& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_LoadingProgress* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_LoadingProgress*>(
               &_CCLCMsg_LoadingProgress_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(CCLCMsg_LoadingProgress& a, CCLCMsg_LoadingProgress& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_LoadingProgress* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_LoadingProgress* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_LoadingProgress* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_LoadingProgress>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_LoadingProgress& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_LoadingProgress& from) {
    CCLCMsg_LoadingProgress::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_LoadingProgress* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_LoadingProgress";
  }
  protected:
  explicit CCLCMsg_LoadingProgress(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProgressFieldNumber = 1,
  };
  // optional int32 progress = 1;
  bool has_progress() const;
  private:
  bool _internal_has_progress() const;
  public:
  void clear_progress();
  int32_t progress() const;
  void set_progress(int32_t value);
  private:
  int32_t _internal_progress() const;
  void _internal_set_progress(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CCLCMsg_LoadingProgress)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t progress_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CCLCMsg_SplitPlayerConnect final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_SplitPlayerConnect) */ {
 public:
  inline CCLCMsg_SplitPlayerConnect() : CCLCMsg_SplitPlayerConnect(nullptr) {}
  ~CCLCMsg_SplitPlayerConnect() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_SplitPlayerConnect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_SplitPlayerConnect(const CCLCMsg_SplitPlayerConnect& from);
  CCLCMsg_SplitPlayerConnect(CCLCMsg_SplitPlayerConnect&& from) noexcept
    : CCLCMsg_SplitPlayerConnect() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_SplitPlayerConnect& operator=(const CCLCMsg_SplitPlayerConnect& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_SplitPlayerConnect& operator=(CCLCMsg_SplitPlayerConnect&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_SplitPlayerConnect& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_SplitPlayerConnect* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_SplitPlayerConnect*>(
               &_CCLCMsg_SplitPlayerConnect_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(CCLCMsg_SplitPlayerConnect& a, CCLCMsg_SplitPlayerConnect& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_SplitPlayerConnect* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_SplitPlayerConnect* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_SplitPlayerConnect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_SplitPlayerConnect>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_SplitPlayerConnect& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_SplitPlayerConnect& from) {
    CCLCMsg_SplitPlayerConnect::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_SplitPlayerConnect* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_SplitPlayerConnect";
  }
  protected:
  explicit CCLCMsg_SplitPlayerConnect(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPlayernameFieldNumber = 1,
  };
  // optional string playername = 1;
  bool has_playername() const;
  private:
  bool _internal_has_playername() const;
  public:
  void clear_playername();
  const std::string& playername() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_playername(ArgT0&& arg0, ArgT... args);
  std::string* mutable_playername();
  PROTOBUF_NODISCARD std::string* release_playername();
  void set_allocated_playername(std::string* playername);
  private:
  const std::string& _internal_playername() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_playername(const std::string& value);
  std::string* _internal_mutable_playername();
  public:

  // @@protoc_insertion_point(class_scope:CCLCMsg_SplitPlayerConnect)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr playername_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CCLCMsg_SplitPlayerDisconnect final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_SplitPlayerDisconnect) */ {
 public:
  inline CCLCMsg_SplitPlayerDisconnect() : CCLCMsg_SplitPlayerDisconnect(nullptr) {}
  ~CCLCMsg_SplitPlayerDisconnect() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_SplitPlayerDisconnect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_SplitPlayerDisconnect(const CCLCMsg_SplitPlayerDisconnect& from);
  CCLCMsg_SplitPlayerDisconnect(CCLCMsg_SplitPlayerDisconnect&& from) noexcept
    : CCLCMsg_SplitPlayerDisconnect() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_SplitPlayerDisconnect& operator=(const CCLCMsg_SplitPlayerDisconnect& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_SplitPlayerDisconnect& operator=(CCLCMsg_SplitPlayerDisconnect&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_SplitPlayerDisconnect& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_SplitPlayerDisconnect* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_SplitPlayerDisconnect*>(
               &_CCLCMsg_SplitPlayerDisconnect_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(CCLCMsg_SplitPlayerDisconnect& a, CCLCMsg_SplitPlayerDisconnect& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_SplitPlayerDisconnect* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_SplitPlayerDisconnect* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_SplitPlayerDisconnect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_SplitPlayerDisconnect>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_SplitPlayerDisconnect& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_SplitPlayerDisconnect& from) {
    CCLCMsg_SplitPlayerDisconnect::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_SplitPlayerDisconnect* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_SplitPlayerDisconnect";
  }
  protected:
  explicit CCLCMsg_SplitPlayerDisconnect(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSlotFieldNumber = 1,
  };
  // optional int32 slot = 1;
  bool has_slot() const;
  private:
  bool _internal_has_slot() const;
  public:
  void clear_slot();
  int32_t slot() const;
  void set_slot(int32_t value);
  private:
  int32_t _internal_slot() const;
  void _internal_set_slot(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CCLCMsg_SplitPlayerDisconnect)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t slot_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CCLCMsg_ServerStatus final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_ServerStatus) */ {
 public:
  inline CCLCMsg_ServerStatus() : CCLCMsg_ServerStatus(nullptr) {}
  ~CCLCMsg_ServerStatus() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_ServerStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_ServerStatus(const CCLCMsg_ServerStatus& from);
  CCLCMsg_ServerStatus(CCLCMsg_ServerStatus&& from) noexcept
    : CCLCMsg_ServerStatus() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_ServerStatus& operator=(const CCLCMsg_ServerStatus& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_ServerStatus& operator=(CCLCMsg_ServerStatus&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_ServerStatus& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_ServerStatus* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_ServerStatus*>(
               &_CCLCMsg_ServerStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(CCLCMsg_ServerStatus& a, CCLCMsg_ServerStatus& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_ServerStatus* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_ServerStatus* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_ServerStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_ServerStatus>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_ServerStatus& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_ServerStatus& from) {
    CCLCMsg_ServerStatus::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_ServerStatus* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_ServerStatus";
  }
  protected:
  explicit CCLCMsg_ServerStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSimplifiedFieldNumber = 1,
  };
  // optional bool simplified = 1;
  bool has_simplified() const;
  private:
  bool _internal_has_simplified() const;
  public:
  void clear_simplified();
  bool simplified() const;
  void set_simplified(bool value);
  private:
  bool _internal_simplified() const;
  void _internal_set_simplified(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CCLCMsg_ServerStatus)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    bool simplified_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CCLCMsg_RequestPause final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_RequestPause) */ {
 public:
  inline CCLCMsg_RequestPause() : CCLCMsg_RequestPause(nullptr) {}
  ~CCLCMsg_RequestPause() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_RequestPause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_RequestPause(const CCLCMsg_RequestPause& from);
  CCLCMsg_RequestPause(CCLCMsg_RequestPause&& from) noexcept
    : CCLCMsg_RequestPause() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_RequestPause& operator=(const CCLCMsg_RequestPause& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_RequestPause& operator=(CCLCMsg_RequestPause&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_RequestPause& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_RequestPause* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_RequestPause*>(
               &_CCLCMsg_RequestPause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(CCLCMsg_RequestPause& a, CCLCMsg_RequestPause& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_RequestPause* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_RequestPause* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_RequestPause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_RequestPause>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_RequestPause& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_RequestPause& from) {
    CCLCMsg_RequestPause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_RequestPause* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_RequestPause";
  }
  protected:
  explicit CCLCMsg_RequestPause(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPauseTypeFieldNumber = 1,
    kPauseGroupFieldNumber = 2,
  };
  // optional .RequestPause_t pause_type = 1 [default = RP_PAUSE];
  bool has_pause_type() const;
  private:
  bool _internal_has_pause_type() const;
  public:
  void clear_pause_type();
  ::RequestPause_t pause_type() const;
  void set_pause_type(::RequestPause_t value);
  private:
  ::RequestPause_t _internal_pause_type() const;
  void _internal_set_pause_type(::RequestPause_t value);
  public:

  // optional int32 pause_group = 2;
  bool has_pause_group() const;
  private:
  bool _internal_has_pause_group() const;
  public:
  void clear_pause_group();
  int32_t pause_group() const;
  void set_pause_group(int32_t value);
  private:
  int32_t _internal_pause_group() const;
  void _internal_set_pause_group(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CCLCMsg_RequestPause)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int pause_type_;
    int32_t pause_group_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CCLCMsg_CmdKeyValues final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_CmdKeyValues) */ {
 public:
  inline CCLCMsg_CmdKeyValues() : CCLCMsg_CmdKeyValues(nullptr) {}
  ~CCLCMsg_CmdKeyValues() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_CmdKeyValues(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_CmdKeyValues(const CCLCMsg_CmdKeyValues& from);
  CCLCMsg_CmdKeyValues(CCLCMsg_CmdKeyValues&& from) noexcept
    : CCLCMsg_CmdKeyValues() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_CmdKeyValues& operator=(const CCLCMsg_CmdKeyValues& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_CmdKeyValues& operator=(CCLCMsg_CmdKeyValues&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_CmdKeyValues& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_CmdKeyValues* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_CmdKeyValues*>(
               &_CCLCMsg_CmdKeyValues_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(CCLCMsg_CmdKeyValues& a, CCLCMsg_CmdKeyValues& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_CmdKeyValues* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_CmdKeyValues* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_CmdKeyValues* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_CmdKeyValues>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_CmdKeyValues& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_CmdKeyValues& from) {
    CCLCMsg_CmdKeyValues::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_CmdKeyValues* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_CmdKeyValues";
  }
  protected:
  explicit CCLCMsg_CmdKeyValues(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
  };
  // optional bytes data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // @@protoc_insertion_point(class_scope:CCLCMsg_CmdKeyValues)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CCLCMsg_RconServerDetails final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_RconServerDetails) */ {
 public:
  inline CCLCMsg_RconServerDetails() : CCLCMsg_RconServerDetails(nullptr) {}
  ~CCLCMsg_RconServerDetails() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_RconServerDetails(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_RconServerDetails(const CCLCMsg_RconServerDetails& from);
  CCLCMsg_RconServerDetails(CCLCMsg_RconServerDetails&& from) noexcept
    : CCLCMsg_RconServerDetails() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_RconServerDetails& operator=(const CCLCMsg_RconServerDetails& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_RconServerDetails& operator=(CCLCMsg_RconServerDetails&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_RconServerDetails& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_RconServerDetails* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_RconServerDetails*>(
               &_CCLCMsg_RconServerDetails_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(CCLCMsg_RconServerDetails& a, CCLCMsg_RconServerDetails& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_RconServerDetails* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_RconServerDetails* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_RconServerDetails* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_RconServerDetails>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_RconServerDetails& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_RconServerDetails& from) {
    CCLCMsg_RconServerDetails::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_RconServerDetails* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_RconServerDetails";
  }
  protected:
  explicit CCLCMsg_RconServerDetails(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTokenFieldNumber = 1,
  };
  // optional bytes token = 1;
  bool has_token() const;
  private:
  bool _internal_has_token() const;
  public:
  void clear_token();
  const std::string& token() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_token(ArgT0&& arg0, ArgT... args);
  std::string* mutable_token();
  PROTOBUF_NODISCARD std::string* release_token();
  void set_allocated_token(std::string* token);
  private:
  const std::string& _internal_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
  std::string* _internal_mutable_token();
  public:

  // @@protoc_insertion_point(class_scope:CCLCMsg_RconServerDetails)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CCLCMsg_Diagnostic final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_Diagnostic) */ {
 public:
  inline CCLCMsg_Diagnostic() : CCLCMsg_Diagnostic(nullptr) {}
  ~CCLCMsg_Diagnostic() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_Diagnostic(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_Diagnostic(const CCLCMsg_Diagnostic& from);
  CCLCMsg_Diagnostic(CCLCMsg_Diagnostic&& from) noexcept
    : CCLCMsg_Diagnostic() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_Diagnostic& operator=(const CCLCMsg_Diagnostic& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_Diagnostic& operator=(CCLCMsg_Diagnostic&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_Diagnostic& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_Diagnostic* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_Diagnostic*>(
               &_CCLCMsg_Diagnostic_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(CCLCMsg_Diagnostic& a, CCLCMsg_Diagnostic& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_Diagnostic* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_Diagnostic* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_Diagnostic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_Diagnostic>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_Diagnostic& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_Diagnostic& from) {
    CCLCMsg_Diagnostic::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_Diagnostic* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_Diagnostic";
  }
  protected:
  explicit CCLCMsg_Diagnostic(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPerfSamplesFieldNumber = 5,
    kSystemSpecsFieldNumber = 1,
    kVprofReportFieldNumber = 2,
    kDownstreamFlowFieldNumber = 3,
    kUpstreamFlowFieldNumber = 4,
  };
  // repeated .CMsgSource2PerfIntervalSample perf_samples = 5;
  int perf_samples_size() const;
  private:
  int _internal_perf_samples_size() const;
  public:
  void clear_perf_samples();
  ::CMsgSource2PerfIntervalSample* mutable_perf_samples(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSource2PerfIntervalSample >*
      mutable_perf_samples();
  private:
  const ::CMsgSource2PerfIntervalSample& _internal_perf_samples(int index) const;
  ::CMsgSource2PerfIntervalSample* _internal_add_perf_samples();
  public:
  const ::CMsgSource2PerfIntervalSample& perf_samples(int index) const;
  ::CMsgSource2PerfIntervalSample* add_perf_samples();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSource2PerfIntervalSample >&
      perf_samples() const;

  // optional .CMsgSource2SystemSpecs system_specs = 1;
  bool has_system_specs() const;
  private:
  bool _internal_has_system_specs() const;
  public:
  void clear_system_specs();
  const ::CMsgSource2SystemSpecs& system_specs() const;
  PROTOBUF_NODISCARD ::CMsgSource2SystemSpecs* release_system_specs();
  ::CMsgSource2SystemSpecs* mutable_system_specs();
  void set_allocated_system_specs(::CMsgSource2SystemSpecs* system_specs);
  private:
  const ::CMsgSource2SystemSpecs& _internal_system_specs() const;
  ::CMsgSource2SystemSpecs* _internal_mutable_system_specs();
  public:
  void unsafe_arena_set_allocated_system_specs(
      ::CMsgSource2SystemSpecs* system_specs);
  ::CMsgSource2SystemSpecs* unsafe_arena_release_system_specs();

  // optional .CMsgSource2VProfLiteReport vprof_report = 2;
  bool has_vprof_report() const;
  private:
  bool _internal_has_vprof_report() const;
  public:
  void clear_vprof_report();
  const ::CMsgSource2VProfLiteReport& vprof_report() const;
  PROTOBUF_NODISCARD ::CMsgSource2VProfLiteReport* release_vprof_report();
  ::CMsgSource2VProfLiteReport* mutable_vprof_report();
  void set_allocated_vprof_report(::CMsgSource2VProfLiteReport* vprof_report);
  private:
  const ::CMsgSource2VProfLiteReport& _internal_vprof_report() const;
  ::CMsgSource2VProfLiteReport* _internal_mutable_vprof_report();
  public:
  void unsafe_arena_set_allocated_vprof_report(
      ::CMsgSource2VProfLiteReport* vprof_report);
  ::CMsgSource2VProfLiteReport* unsafe_arena_release_vprof_report();

  // optional .CMsgSource2NetworkFlowQuality downstream_flow = 3;
  bool has_downstream_flow() const;
  private:
  bool _internal_has_downstream_flow() const;
  public:
  void clear_downstream_flow();
  const ::CMsgSource2NetworkFlowQuality& downstream_flow() const;
  PROTOBUF_NODISCARD ::CMsgSource2NetworkFlowQuality* release_downstream_flow();
  ::CMsgSource2NetworkFlowQuality* mutable_downstream_flow();
  void set_allocated_downstream_flow(::CMsgSource2NetworkFlowQuality* downstream_flow);
  private:
  const ::CMsgSource2NetworkFlowQuality& _internal_downstream_flow() const;
  ::CMsgSource2NetworkFlowQuality* _internal_mutable_downstream_flow();
  public:
  void unsafe_arena_set_allocated_downstream_flow(
      ::CMsgSource2NetworkFlowQuality* downstream_flow);
  ::CMsgSource2NetworkFlowQuality* unsafe_arena_release_downstream_flow();

  // optional .CMsgSource2NetworkFlowQuality upstream_flow = 4;
  bool has_upstream_flow() const;
  private:
  bool _internal_has_upstream_flow() const;
  public:
  void clear_upstream_flow();
  const ::CMsgSource2NetworkFlowQuality& upstream_flow() const;
  PROTOBUF_NODISCARD ::CMsgSource2NetworkFlowQuality* release_upstream_flow();
  ::CMsgSource2NetworkFlowQuality* mutable_upstream_flow();
  void set_allocated_upstream_flow(::CMsgSource2NetworkFlowQuality* upstream_flow);
  private:
  const ::CMsgSource2NetworkFlowQuality& _internal_upstream_flow() const;
  ::CMsgSource2NetworkFlowQuality* _internal_mutable_upstream_flow();
  public:
  void unsafe_arena_set_allocated_upstream_flow(
      ::CMsgSource2NetworkFlowQuality* upstream_flow);
  ::CMsgSource2NetworkFlowQuality* unsafe_arena_release_upstream_flow();

  // @@protoc_insertion_point(class_scope:CCLCMsg_Diagnostic)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSource2PerfIntervalSample > perf_samples_;
    ::CMsgSource2SystemSpecs* system_specs_;
    ::CMsgSource2VProfLiteReport* vprof_report_;
    ::CMsgSource2NetworkFlowQuality* downstream_flow_;
    ::CMsgSource2NetworkFlowQuality* upstream_flow_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_ServerInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_ServerInfo) */ {
 public:
  inline CSVCMsg_ServerInfo() : CSVCMsg_ServerInfo(nullptr) {}
  ~CSVCMsg_ServerInfo() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_ServerInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_ServerInfo(const CSVCMsg_ServerInfo& from);
  CSVCMsg_ServerInfo(CSVCMsg_ServerInfo&& from) noexcept
    : CSVCMsg_ServerInfo() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_ServerInfo& operator=(const CSVCMsg_ServerInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_ServerInfo& operator=(CSVCMsg_ServerInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_ServerInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_ServerInfo* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_ServerInfo*>(
               &_CSVCMsg_ServerInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(CSVCMsg_ServerInfo& a, CSVCMsg_ServerInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_ServerInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_ServerInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_ServerInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_ServerInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_ServerInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_ServerInfo& from) {
    CSVCMsg_ServerInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_ServerInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_ServerInfo";
  }
  protected:
  explicit CSVCMsg_ServerInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kGameDirFieldNumber = 14,
    kMapNameFieldNumber = 15,
    kSkyNameFieldNumber = 16,
    kHostNameFieldNumber = 17,
    kAddonNameFieldNumber = 18,
    kGameSessionManifestFieldNumber = 20,
    kGameSessionConfigFieldNumber = 19,
    kProtocolFieldNumber = 1,
    kServerCountFieldNumber = 2,
    kIsDedicatedFieldNumber = 3,
    kIsHltvFieldNumber = 4,
    kCOsFieldNumber = 6,
    kMaxClientsFieldNumber = 10,
    kMaxClassesFieldNumber = 11,
    kTickIntervalFieldNumber = 13,
    kPlayerSlotFieldNumber = 12,
  };
  // optional string game_dir = 14;
  bool has_game_dir() const;
  private:
  bool _internal_has_game_dir() const;
  public:
  void clear_game_dir();
  const std::string& game_dir() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_game_dir(ArgT0&& arg0, ArgT... args);
  std::string* mutable_game_dir();
  PROTOBUF_NODISCARD std::string* release_game_dir();
  void set_allocated_game_dir(std::string* game_dir);
  private:
  const std::string& _internal_game_dir() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_game_dir(const std::string& value);
  std::string* _internal_mutable_game_dir();
  public:

  // optional string map_name = 15;
  bool has_map_name() const;
  private:
  bool _internal_has_map_name() const;
  public:
  void clear_map_name();
  const std::string& map_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_map_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_map_name();
  PROTOBUF_NODISCARD std::string* release_map_name();
  void set_allocated_map_name(std::string* map_name);
  private:
  const std::string& _internal_map_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_map_name(const std::string& value);
  std::string* _internal_mutable_map_name();
  public:

  // optional string sky_name = 16;
  bool has_sky_name() const;
  private:
  bool _internal_has_sky_name() const;
  public:
  void clear_sky_name();
  const std::string& sky_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sky_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sky_name();
  PROTOBUF_NODISCARD std::string* release_sky_name();
  void set_allocated_sky_name(std::string* sky_name);
  private:
  const std::string& _internal_sky_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sky_name(const std::string& value);
  std::string* _internal_mutable_sky_name();
  public:

  // optional string host_name = 17;
  bool has_host_name() const;
  private:
  bool _internal_has_host_name() const;
  public:
  void clear_host_name();
  const std::string& host_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_host_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_host_name();
  PROTOBUF_NODISCARD std::string* release_host_name();
  void set_allocated_host_name(std::string* host_name);
  private:
  const std::string& _internal_host_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_host_name(const std::string& value);
  std::string* _internal_mutable_host_name();
  public:

  // optional string addon_name = 18;
  bool has_addon_name() const;
  private:
  bool _internal_has_addon_name() const;
  public:
  void clear_addon_name();
  const std::string& addon_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_addon_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_addon_name();
  PROTOBUF_NODISCARD std::string* release_addon_name();
  void set_allocated_addon_name(std::string* addon_name);
  private:
  const std::string& _internal_addon_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_addon_name(const std::string& value);
  std::string* _internal_mutable_addon_name();
  public:

  // optional bytes game_session_manifest = 20;
  bool has_game_session_manifest() const;
  private:
  bool _internal_has_game_session_manifest() const;
  public:
  void clear_game_session_manifest();
  const std::string& game_session_manifest() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_game_session_manifest(ArgT0&& arg0, ArgT... args);
  std::string* mutable_game_session_manifest();
  PROTOBUF_NODISCARD std::string* release_game_session_manifest();
  void set_allocated_game_session_manifest(std::string* game_session_manifest);
  private:
  const std::string& _internal_game_session_manifest() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_game_session_manifest(const std::string& value);
  std::string* _internal_mutable_game_session_manifest();
  public:

  // optional .CSVCMsg_GameSessionConfiguration game_session_config = 19;
  bool has_game_session_config() const;
  private:
  bool _internal_has_game_session_config() const;
  public:
  void clear_game_session_config();
  const ::CSVCMsg_GameSessionConfiguration& game_session_config() const;
  PROTOBUF_NODISCARD ::CSVCMsg_GameSessionConfiguration* release_game_session_config();
  ::CSVCMsg_GameSessionConfiguration* mutable_game_session_config();
  void set_allocated_game_session_config(::CSVCMsg_GameSessionConfiguration* game_session_config);
  private:
  const ::CSVCMsg_GameSessionConfiguration& _internal_game_session_config() const;
  ::CSVCMsg_GameSessionConfiguration* _internal_mutable_game_session_config();
  public:
  void unsafe_arena_set_allocated_game_session_config(
      ::CSVCMsg_GameSessionConfiguration* game_session_config);
  ::CSVCMsg_GameSessionConfiguration* unsafe_arena_release_game_session_config();

  // optional int32 protocol = 1;
  bool has_protocol() const;
  private:
  bool _internal_has_protocol() const;
  public:
  void clear_protocol();
  int32_t protocol() const;
  void set_protocol(int32_t value);
  private:
  int32_t _internal_protocol() const;
  void _internal_set_protocol(int32_t value);
  public:

  // optional int32 server_count = 2;
  bool has_server_count() const;
  private:
  bool _internal_has_server_count() const;
  public:
  void clear_server_count();
  int32_t server_count() const;
  void set_server_count(int32_t value);
  private:
  int32_t _internal_server_count() const;
  void _internal_set_server_count(int32_t value);
  public:

  // optional bool is_dedicated = 3;
  bool has_is_dedicated() const;
  private:
  bool _internal_has_is_dedicated() const;
  public:
  void clear_is_dedicated();
  bool is_dedicated() const;
  void set_is_dedicated(bool value);
  private:
  bool _internal_is_dedicated() const;
  void _internal_set_is_dedicated(bool value);
  public:

  // optional bool is_hltv = 4;
  bool has_is_hltv() const;
  private:
  bool _internal_has_is_hltv() const;
  public:
  void clear_is_hltv();
  bool is_hltv() const;
  void set_is_hltv(bool value);
  private:
  bool _internal_is_hltv() const;
  void _internal_set_is_hltv(bool value);
  public:

  // optional int32 c_os = 6;
  bool has_c_os() const;
  private:
  bool _internal_has_c_os() const;
  public:
  void clear_c_os();
  int32_t c_os() const;
  void set_c_os(int32_t value);
  private:
  int32_t _internal_c_os() const;
  void _internal_set_c_os(int32_t value);
  public:

  // optional int32 max_clients = 10;
  bool has_max_clients() const;
  private:
  bool _internal_has_max_clients() const;
  public:
  void clear_max_clients();
  int32_t max_clients() const;
  void set_max_clients(int32_t value);
  private:
  int32_t _internal_max_clients() const;
  void _internal_set_max_clients(int32_t value);
  public:

  // optional int32 max_classes = 11;
  bool has_max_classes() const;
  private:
  bool _internal_has_max_classes() const;
  public:
  void clear_max_classes();
  int32_t max_classes() const;
  void set_max_classes(int32_t value);
  private:
  int32_t _internal_max_classes() const;
  void _internal_set_max_classes(int32_t value);
  public:

  // optional float tick_interval = 13;
  bool has_tick_interval() const;
  private:
  bool _internal_has_tick_interval() const;
  public:
  void clear_tick_interval();
  float tick_interval() const;
  void set_tick_interval(float value);
  private:
  float _internal_tick_interval() const;
  void _internal_set_tick_interval(float value);
  public:

  // optional int32 player_slot = 12 [default = -1];
  bool has_player_slot() const;
  private:
  bool _internal_has_player_slot() const;
  public:
  void clear_player_slot();
  int32_t player_slot() const;
  void set_player_slot(int32_t value);
  private:
  int32_t _internal_player_slot() const;
  void _internal_set_player_slot(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_ServerInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr game_dir_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sky_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr host_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr addon_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr game_session_manifest_;
    ::CSVCMsg_GameSessionConfiguration* game_session_config_;
    int32_t protocol_;
    int32_t server_count_;
    bool is_dedicated_;
    bool is_hltv_;
    int32_t c_os_;
    int32_t max_clients_;
    int32_t max_classes_;
    float tick_interval_;
    int32_t player_slot_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_ClassInfo_class_t final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_ClassInfo.class_t) */ {
 public:
  inline CSVCMsg_ClassInfo_class_t() : CSVCMsg_ClassInfo_class_t(nullptr) {}
  ~CSVCMsg_ClassInfo_class_t() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_ClassInfo_class_t(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_ClassInfo_class_t(const CSVCMsg_ClassInfo_class_t& from);
  CSVCMsg_ClassInfo_class_t(CSVCMsg_ClassInfo_class_t&& from) noexcept
    : CSVCMsg_ClassInfo_class_t() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_ClassInfo_class_t& operator=(const CSVCMsg_ClassInfo_class_t& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_ClassInfo_class_t& operator=(CSVCMsg_ClassInfo_class_t&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_ClassInfo_class_t& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_ClassInfo_class_t* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_ClassInfo_class_t*>(
               &_CSVCMsg_ClassInfo_class_t_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(CSVCMsg_ClassInfo_class_t& a, CSVCMsg_ClassInfo_class_t& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_ClassInfo_class_t* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_ClassInfo_class_t* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_ClassInfo_class_t* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_ClassInfo_class_t>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_ClassInfo_class_t& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_ClassInfo_class_t& from) {
    CSVCMsg_ClassInfo_class_t::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_ClassInfo_class_t* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_ClassInfo.class_t";
  }
  protected:
  explicit CSVCMsg_ClassInfo_class_t(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kClassNameFieldNumber = 3,
    kClassIdFieldNumber = 1,
  };
  // optional string class_name = 3;
  bool has_class_name() const;
  private:
  bool _internal_has_class_name() const;
  public:
  void clear_class_name();
  const std::string& class_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_class_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_class_name();
  PROTOBUF_NODISCARD std::string* release_class_name();
  void set_allocated_class_name(std::string* class_name);
  private:
  const std::string& _internal_class_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_class_name(const std::string& value);
  std::string* _internal_mutable_class_name();
  public:

  // optional int32 class_id = 1;
  bool has_class_id() const;
  private:
  bool _internal_has_class_id() const;
  public:
  void clear_class_id();
  int32_t class_id() const;
  void set_class_id(int32_t value);
  private:
  int32_t _internal_class_id() const;
  void _internal_set_class_id(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_ClassInfo.class_t)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr class_name_;
    int32_t class_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_ClassInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_ClassInfo) */ {
 public:
  inline CSVCMsg_ClassInfo() : CSVCMsg_ClassInfo(nullptr) {}
  ~CSVCMsg_ClassInfo() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_ClassInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_ClassInfo(const CSVCMsg_ClassInfo& from);
  CSVCMsg_ClassInfo(CSVCMsg_ClassInfo&& from) noexcept
    : CSVCMsg_ClassInfo() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_ClassInfo& operator=(const CSVCMsg_ClassInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_ClassInfo& operator=(CSVCMsg_ClassInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_ClassInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_ClassInfo* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_ClassInfo*>(
               &_CSVCMsg_ClassInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(CSVCMsg_ClassInfo& a, CSVCMsg_ClassInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_ClassInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_ClassInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_ClassInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_ClassInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_ClassInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_ClassInfo& from) {
    CSVCMsg_ClassInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_ClassInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_ClassInfo";
  }
  protected:
  explicit CSVCMsg_ClassInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef CSVCMsg_ClassInfo_class_t class_t;

  // accessors -------------------------------------------------------

  enum : int {
    kClassesFieldNumber = 2,
    kCreateOnClientFieldNumber = 1,
  };
  // repeated .CSVCMsg_ClassInfo.class_t classes = 2;
  int classes_size() const;
  private:
  int _internal_classes_size() const;
  public:
  void clear_classes();
  ::CSVCMsg_ClassInfo_class_t* mutable_classes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_ClassInfo_class_t >*
      mutable_classes();
  private:
  const ::CSVCMsg_ClassInfo_class_t& _internal_classes(int index) const;
  ::CSVCMsg_ClassInfo_class_t* _internal_add_classes();
  public:
  const ::CSVCMsg_ClassInfo_class_t& classes(int index) const;
  ::CSVCMsg_ClassInfo_class_t* add_classes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_ClassInfo_class_t >&
      classes() const;

  // optional bool create_on_client = 1;
  bool has_create_on_client() const;
  private:
  bool _internal_has_create_on_client() const;
  public:
  void clear_create_on_client();
  bool create_on_client() const;
  void set_create_on_client(bool value);
  private:
  bool _internal_create_on_client() const;
  void _internal_set_create_on_client(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_ClassInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_ClassInfo_class_t > classes_;
    bool create_on_client_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_SetPause final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_SetPause) */ {
 public:
  inline CSVCMsg_SetPause() : CSVCMsg_SetPause(nullptr) {}
  ~CSVCMsg_SetPause() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_SetPause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_SetPause(const CSVCMsg_SetPause& from);
  CSVCMsg_SetPause(CSVCMsg_SetPause&& from) noexcept
    : CSVCMsg_SetPause() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_SetPause& operator=(const CSVCMsg_SetPause& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_SetPause& operator=(CSVCMsg_SetPause&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_SetPause& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_SetPause* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_SetPause*>(
               &_CSVCMsg_SetPause_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(CSVCMsg_SetPause& a, CSVCMsg_SetPause& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_SetPause* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_SetPause* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_SetPause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_SetPause>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_SetPause& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_SetPause& from) {
    CSVCMsg_SetPause::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_SetPause* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_SetPause";
  }
  protected:
  explicit CSVCMsg_SetPause(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPausedFieldNumber = 1,
  };
  // optional bool paused = 1;
  bool has_paused() const;
  private:
  bool _internal_has_paused() const;
  public:
  void clear_paused();
  bool paused() const;
  void set_paused(bool value);
  private:
  bool _internal_paused() const;
  void _internal_set_paused(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_SetPause)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    bool paused_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_VoiceInit final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_VoiceInit) */ {
 public:
  inline CSVCMsg_VoiceInit() : CSVCMsg_VoiceInit(nullptr) {}
  ~CSVCMsg_VoiceInit() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_VoiceInit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_VoiceInit(const CSVCMsg_VoiceInit& from);
  CSVCMsg_VoiceInit(CSVCMsg_VoiceInit&& from) noexcept
    : CSVCMsg_VoiceInit() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_VoiceInit& operator=(const CSVCMsg_VoiceInit& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_VoiceInit& operator=(CSVCMsg_VoiceInit&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_VoiceInit& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_VoiceInit* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_VoiceInit*>(
               &_CSVCMsg_VoiceInit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(CSVCMsg_VoiceInit& a, CSVCMsg_VoiceInit& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_VoiceInit* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_VoiceInit* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_VoiceInit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_VoiceInit>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_VoiceInit& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_VoiceInit& from) {
    CSVCMsg_VoiceInit::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_VoiceInit* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_VoiceInit";
  }
  protected:
  explicit CSVCMsg_VoiceInit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCodecFieldNumber = 2,
    kQualityFieldNumber = 1,
    kVersionFieldNumber = 3,
  };
  // optional string codec = 2;
  bool has_codec() const;
  private:
  bool _internal_has_codec() const;
  public:
  void clear_codec();
  const std::string& codec() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_codec(ArgT0&& arg0, ArgT... args);
  std::string* mutable_codec();
  PROTOBUF_NODISCARD std::string* release_codec();
  void set_allocated_codec(std::string* codec);
  private:
  const std::string& _internal_codec() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_codec(const std::string& value);
  std::string* _internal_mutable_codec();
  public:

  // optional int32 quality = 1;
  bool has_quality() const;
  private:
  bool _internal_has_quality() const;
  public:
  void clear_quality();
  int32_t quality() const;
  void set_quality(int32_t value);
  private:
  int32_t _internal_quality() const;
  void _internal_set_quality(int32_t value);
  public:

  // optional int32 version = 3 [default = 0];
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  int32_t version() const;
  void set_version(int32_t value);
  private:
  int32_t _internal_version() const;
  void _internal_set_version(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_VoiceInit)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr codec_;
    int32_t quality_;
    int32_t version_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_Print final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_Print) */ {
 public:
  inline CSVCMsg_Print() : CSVCMsg_Print(nullptr) {}
  ~CSVCMsg_Print() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_Print(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_Print(const CSVCMsg_Print& from);
  CSVCMsg_Print(CSVCMsg_Print&& from) noexcept
    : CSVCMsg_Print() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_Print& operator=(const CSVCMsg_Print& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_Print& operator=(CSVCMsg_Print&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_Print& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_Print* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_Print*>(
               &_CSVCMsg_Print_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(CSVCMsg_Print& a, CSVCMsg_Print& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_Print* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_Print* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_Print* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_Print>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_Print& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_Print& from) {
    CSVCMsg_Print::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_Print* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_Print";
  }
  protected:
  explicit CSVCMsg_Print(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTextFieldNumber = 1,
  };
  // optional string text = 1;
  bool has_text() const;
  private:
  bool _internal_has_text() const;
  public:
  void clear_text();
  const std::string& text() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_text(ArgT0&& arg0, ArgT... args);
  std::string* mutable_text();
  PROTOBUF_NODISCARD std::string* release_text();
  void set_allocated_text(std::string* text);
  private:
  const std::string& _internal_text() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
  std::string* _internal_mutable_text();
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_Print)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_Sounds_sounddata_t final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_Sounds.sounddata_t) */ {
 public:
  inline CSVCMsg_Sounds_sounddata_t() : CSVCMsg_Sounds_sounddata_t(nullptr) {}
  ~CSVCMsg_Sounds_sounddata_t() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_Sounds_sounddata_t(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_Sounds_sounddata_t(const CSVCMsg_Sounds_sounddata_t& from);
  CSVCMsg_Sounds_sounddata_t(CSVCMsg_Sounds_sounddata_t&& from) noexcept
    : CSVCMsg_Sounds_sounddata_t() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_Sounds_sounddata_t& operator=(const CSVCMsg_Sounds_sounddata_t& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_Sounds_sounddata_t& operator=(CSVCMsg_Sounds_sounddata_t&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_Sounds_sounddata_t& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_Sounds_sounddata_t* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_Sounds_sounddata_t*>(
               &_CSVCMsg_Sounds_sounddata_t_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(CSVCMsg_Sounds_sounddata_t& a, CSVCMsg_Sounds_sounddata_t& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_Sounds_sounddata_t* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_Sounds_sounddata_t* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_Sounds_sounddata_t* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_Sounds_sounddata_t>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_Sounds_sounddata_t& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_Sounds_sounddata_t& from) {
    CSVCMsg_Sounds_sounddata_t::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_Sounds_sounddata_t* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_Sounds.sounddata_t";
  }
  protected:
  explicit CSVCMsg_Sounds_sounddata_t(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOriginXFieldNumber = 1,
    kOriginYFieldNumber = 2,
    kOriginZFieldNumber = 3,
    kVolumeFieldNumber = 4,
    kDelayValueFieldNumber = 5,
    kSequenceNumberFieldNumber = 6,
    kChannelFieldNumber = 8,
    kPitchFieldNumber = 9,
    kFlagsFieldNumber = 10,
    kSoundNumFieldNumber = 11,
    kSoundNumHandleFieldNumber = 12,
    kSpeakerEntityFieldNumber = 13,
    kRandomSeedFieldNumber = 14,
    kSoundLevelFieldNumber = 15,
    kIsSentenceFieldNumber = 16,
    kIsAmbientFieldNumber = 17,
    kGuidFieldNumber = 18,
    kSoundResourceIdFieldNumber = 19,
    kEntityIndexFieldNumber = 7,
  };
  // optional sint32 origin_x = 1;
  bool has_origin_x() const;
  private:
  bool _internal_has_origin_x() const;
  public:
  void clear_origin_x();
  int32_t origin_x() const;
  void set_origin_x(int32_t value);
  private:
  int32_t _internal_origin_x() const;
  void _internal_set_origin_x(int32_t value);
  public:

  // optional sint32 origin_y = 2;
  bool has_origin_y() const;
  private:
  bool _internal_has_origin_y() const;
  public:
  void clear_origin_y();
  int32_t origin_y() const;
  void set_origin_y(int32_t value);
  private:
  int32_t _internal_origin_y() const;
  void _internal_set_origin_y(int32_t value);
  public:

  // optional sint32 origin_z = 3;
  bool has_origin_z() const;
  private:
  bool _internal_has_origin_z() const;
  public:
  void clear_origin_z();
  int32_t origin_z() const;
  void set_origin_z(int32_t value);
  private:
  int32_t _internal_origin_z() const;
  void _internal_set_origin_z(int32_t value);
  public:

  // optional uint32 volume = 4;
  bool has_volume() const;
  private:
  bool _internal_has_volume() const;
  public:
  void clear_volume();
  uint32_t volume() const;
  void set_volume(uint32_t value);
  private:
  uint32_t _internal_volume() const;
  void _internal_set_volume(uint32_t value);
  public:

  // optional float delay_value = 5;
  bool has_delay_value() const;
  private:
  bool _internal_has_delay_value() const;
  public:
  void clear_delay_value();
  float delay_value() const;
  void set_delay_value(float value);
  private:
  float _internal_delay_value() const;
  void _internal_set_delay_value(float value);
  public:

  // optional int32 sequence_number = 6;
  bool has_sequence_number() const;
  private:
  bool _internal_has_sequence_number() const;
  public:
  void clear_sequence_number();
  int32_t sequence_number() const;
  void set_sequence_number(int32_t value);
  private:
  int32_t _internal_sequence_number() const;
  void _internal_set_sequence_number(int32_t value);
  public:

  // optional int32 channel = 8;
  bool has_channel() const;
  private:
  bool _internal_has_channel() const;
  public:
  void clear_channel();
  int32_t channel() const;
  void set_channel(int32_t value);
  private:
  int32_t _internal_channel() const;
  void _internal_set_channel(int32_t value);
  public:

  // optional int32 pitch = 9;
  bool has_pitch() const;
  private:
  bool _internal_has_pitch() const;
  public:
  void clear_pitch();
  int32_t pitch() const;
  void set_pitch(int32_t value);
  private:
  int32_t _internal_pitch() const;
  void _internal_set_pitch(int32_t value);
  public:

  // optional int32 flags = 10;
  bool has_flags() const;
  private:
  bool _internal_has_flags() const;
  public:
  void clear_flags();
  int32_t flags() const;
  void set_flags(int32_t value);
  private:
  int32_t _internal_flags() const;
  void _internal_set_flags(int32_t value);
  public:

  // optional uint32 sound_num = 11;
  bool has_sound_num() const;
  private:
  bool _internal_has_sound_num() const;
  public:
  void clear_sound_num();
  uint32_t sound_num() const;
  void set_sound_num(uint32_t value);
  private:
  uint32_t _internal_sound_num() const;
  void _internal_set_sound_num(uint32_t value);
  public:

  // optional fixed32 sound_num_handle = 12;
  bool has_sound_num_handle() const;
  private:
  bool _internal_has_sound_num_handle() const;
  public:
  void clear_sound_num_handle();
  uint32_t sound_num_handle() const;
  void set_sound_num_handle(uint32_t value);
  private:
  uint32_t _internal_sound_num_handle() const;
  void _internal_set_sound_num_handle(uint32_t value);
  public:

  // optional int32 speaker_entity = 13;
  bool has_speaker_entity() const;
  private:
  bool _internal_has_speaker_entity() const;
  public:
  void clear_speaker_entity();
  int32_t speaker_entity() const;
  void set_speaker_entity(int32_t value);
  private:
  int32_t _internal_speaker_entity() const;
  void _internal_set_speaker_entity(int32_t value);
  public:

  // optional int32 random_seed = 14;
  bool has_random_seed() const;
  private:
  bool _internal_has_random_seed() const;
  public:
  void clear_random_seed();
  int32_t random_seed() const;
  void set_random_seed(int32_t value);
  private:
  int32_t _internal_random_seed() const;
  void _internal_set_random_seed(int32_t value);
  public:

  // optional int32 sound_level = 15;
  bool has_sound_level() const;
  private:
  bool _internal_has_sound_level() const;
  public:
  void clear_sound_level();
  int32_t sound_level() const;
  void set_sound_level(int32_t value);
  private:
  int32_t _internal_sound_level() const;
  void _internal_set_sound_level(int32_t value);
  public:

  // optional bool is_sentence = 16;
  bool has_is_sentence() const;
  private:
  bool _internal_has_is_sentence() const;
  public:
  void clear_is_sentence();
  bool is_sentence() const;
  void set_is_sentence(bool value);
  private:
  bool _internal_is_sentence() const;
  void _internal_set_is_sentence(bool value);
  public:

  // optional bool is_ambient = 17;
  bool has_is_ambient() const;
  private:
  bool _internal_has_is_ambient() const;
  public:
  void clear_is_ambient();
  bool is_ambient() const;
  void set_is_ambient(bool value);
  private:
  bool _internal_is_ambient() const;
  void _internal_set_is_ambient(bool value);
  public:

  // optional uint32 guid = 18;
  bool has_guid() const;
  private:
  bool _internal_has_guid() const;
  public:
  void clear_guid();
  uint32_t guid() const;
  void set_guid(uint32_t value);
  private:
  uint32_t _internal_guid() const;
  void _internal_set_guid(uint32_t value);
  public:

  // optional fixed64 sound_resource_id = 19;
  bool has_sound_resource_id() const;
  private:
  bool _internal_has_sound_resource_id() const;
  public:
  void clear_sound_resource_id();
  uint64_t sound_resource_id() const;
  void set_sound_resource_id(uint64_t value);
  private:
  uint64_t _internal_sound_resource_id() const;
  void _internal_set_sound_resource_id(uint64_t value);
  public:

  // optional int32 entity_index = 7 [default = -1];
  bool has_entity_index() const;
  private:
  bool _internal_has_entity_index() const;
  public:
  void clear_entity_index();
  int32_t entity_index() const;
  void set_entity_index(int32_t value);
  private:
  int32_t _internal_entity_index() const;
  void _internal_set_entity_index(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_Sounds.sounddata_t)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t origin_x_;
    int32_t origin_y_;
    int32_t origin_z_;
    uint32_t volume_;
    float delay_value_;
    int32_t sequence_number_;
    int32_t channel_;
    int32_t pitch_;
    int32_t flags_;
    uint32_t sound_num_;
    uint32_t sound_num_handle_;
    int32_t speaker_entity_;
    int32_t random_seed_;
    int32_t sound_level_;
    bool is_sentence_;
    bool is_ambient_;
    uint32_t guid_;
    uint64_t sound_resource_id_;
    int32_t entity_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_Sounds final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_Sounds) */ {
 public:
  inline CSVCMsg_Sounds() : CSVCMsg_Sounds(nullptr) {}
  ~CSVCMsg_Sounds() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_Sounds(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_Sounds(const CSVCMsg_Sounds& from);
  CSVCMsg_Sounds(CSVCMsg_Sounds&& from) noexcept
    : CSVCMsg_Sounds() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_Sounds& operator=(const CSVCMsg_Sounds& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_Sounds& operator=(CSVCMsg_Sounds&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_Sounds& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_Sounds* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_Sounds*>(
               &_CSVCMsg_Sounds_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  friend void swap(CSVCMsg_Sounds& a, CSVCMsg_Sounds& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_Sounds* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_Sounds* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_Sounds* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_Sounds>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_Sounds& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_Sounds& from) {
    CSVCMsg_Sounds::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_Sounds* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_Sounds";
  }
  protected:
  explicit CSVCMsg_Sounds(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef CSVCMsg_Sounds_sounddata_t sounddata_t;

  // accessors -------------------------------------------------------

  enum : int {
    kSoundsFieldNumber = 2,
    kReliableSoundFieldNumber = 1,
  };
  // repeated .CSVCMsg_Sounds.sounddata_t sounds = 2;
  int sounds_size() const;
  private:
  int _internal_sounds_size() const;
  public:
  void clear_sounds();
  ::CSVCMsg_Sounds_sounddata_t* mutable_sounds(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_Sounds_sounddata_t >*
      mutable_sounds();
  private:
  const ::CSVCMsg_Sounds_sounddata_t& _internal_sounds(int index) const;
  ::CSVCMsg_Sounds_sounddata_t* _internal_add_sounds();
  public:
  const ::CSVCMsg_Sounds_sounddata_t& sounds(int index) const;
  ::CSVCMsg_Sounds_sounddata_t* add_sounds();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_Sounds_sounddata_t >&
      sounds() const;

  // optional bool reliable_sound = 1;
  bool has_reliable_sound() const;
  private:
  bool _internal_has_reliable_sound() const;
  public:
  void clear_reliable_sound();
  bool reliable_sound() const;
  void set_reliable_sound(bool value);
  private:
  bool _internal_reliable_sound() const;
  void _internal_set_reliable_sound(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_Sounds)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_Sounds_sounddata_t > sounds_;
    bool reliable_sound_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_Prefetch final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_Prefetch) */ {
 public:
  inline CSVCMsg_Prefetch() : CSVCMsg_Prefetch(nullptr) {}
  ~CSVCMsg_Prefetch() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_Prefetch(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_Prefetch(const CSVCMsg_Prefetch& from);
  CSVCMsg_Prefetch(CSVCMsg_Prefetch&& from) noexcept
    : CSVCMsg_Prefetch() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_Prefetch& operator=(const CSVCMsg_Prefetch& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_Prefetch& operator=(CSVCMsg_Prefetch&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_Prefetch& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_Prefetch* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_Prefetch*>(
               &_CSVCMsg_Prefetch_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  friend void swap(CSVCMsg_Prefetch& a, CSVCMsg_Prefetch& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_Prefetch* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_Prefetch* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_Prefetch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_Prefetch>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_Prefetch& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_Prefetch& from) {
    CSVCMsg_Prefetch::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_Prefetch* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_Prefetch";
  }
  protected:
  explicit CSVCMsg_Prefetch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSoundIndexFieldNumber = 1,
    kResourceTypeFieldNumber = 2,
  };
  // optional int32 sound_index = 1;
  bool has_sound_index() const;
  private:
  bool _internal_has_sound_index() const;
  public:
  void clear_sound_index();
  int32_t sound_index() const;
  void set_sound_index(int32_t value);
  private:
  int32_t _internal_sound_index() const;
  void _internal_set_sound_index(int32_t value);
  public:

  // optional .PrefetchType resource_type = 2 [default = PFT_SOUND];
  bool has_resource_type() const;
  private:
  bool _internal_has_resource_type() const;
  public:
  void clear_resource_type();
  ::PrefetchType resource_type() const;
  void set_resource_type(::PrefetchType value);
  private:
  ::PrefetchType _internal_resource_type() const;
  void _internal_set_resource_type(::PrefetchType value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_Prefetch)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t sound_index_;
    int resource_type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_SetView final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_SetView) */ {
 public:
  inline CSVCMsg_SetView() : CSVCMsg_SetView(nullptr) {}
  ~CSVCMsg_SetView() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_SetView(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_SetView(const CSVCMsg_SetView& from);
  CSVCMsg_SetView(CSVCMsg_SetView&& from) noexcept
    : CSVCMsg_SetView() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_SetView& operator=(const CSVCMsg_SetView& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_SetView& operator=(CSVCMsg_SetView&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_SetView& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_SetView* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_SetView*>(
               &_CSVCMsg_SetView_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  friend void swap(CSVCMsg_SetView& a, CSVCMsg_SetView& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_SetView* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_SetView* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_SetView* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_SetView>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_SetView& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_SetView& from) {
    CSVCMsg_SetView::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_SetView* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_SetView";
  }
  protected:
  explicit CSVCMsg_SetView(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEntityIndexFieldNumber = 1,
    kSlotFieldNumber = 2,
  };
  // optional int32 entity_index = 1 [default = -1];
  bool has_entity_index() const;
  private:
  bool _internal_has_entity_index() const;
  public:
  void clear_entity_index();
  int32_t entity_index() const;
  void set_entity_index(int32_t value);
  private:
  int32_t _internal_entity_index() const;
  void _internal_set_entity_index(int32_t value);
  public:

  // optional int32 slot = 2 [default = -1];
  bool has_slot() const;
  private:
  bool _internal_has_slot() const;
  public:
  void clear_slot();
  int32_t slot() const;
  void set_slot(int32_t value);
  private:
  int32_t _internal_slot() const;
  void _internal_set_slot(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_SetView)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t entity_index_;
    int32_t slot_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_FixAngle final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_FixAngle) */ {
 public:
  inline CSVCMsg_FixAngle() : CSVCMsg_FixAngle(nullptr) {}
  ~CSVCMsg_FixAngle() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_FixAngle(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_FixAngle(const CSVCMsg_FixAngle& from);
  CSVCMsg_FixAngle(CSVCMsg_FixAngle&& from) noexcept
    : CSVCMsg_FixAngle() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_FixAngle& operator=(const CSVCMsg_FixAngle& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_FixAngle& operator=(CSVCMsg_FixAngle&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_FixAngle& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_FixAngle* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_FixAngle*>(
               &_CSVCMsg_FixAngle_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    25;

  friend void swap(CSVCMsg_FixAngle& a, CSVCMsg_FixAngle& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_FixAngle* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_FixAngle* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_FixAngle* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_FixAngle>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_FixAngle& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_FixAngle& from) {
    CSVCMsg_FixAngle::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_FixAngle* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_FixAngle";
  }
  protected:
  explicit CSVCMsg_FixAngle(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAngleFieldNumber = 2,
    kRelativeFieldNumber = 1,
  };
  // optional .CMsgQAngle angle = 2;
  bool has_angle() const;
  private:
  bool _internal_has_angle() const;
  public:
  void clear_angle();
  const ::CMsgQAngle& angle() const;
  PROTOBUF_NODISCARD ::CMsgQAngle* release_angle();
  ::CMsgQAngle* mutable_angle();
  void set_allocated_angle(::CMsgQAngle* angle);
  private:
  const ::CMsgQAngle& _internal_angle() const;
  ::CMsgQAngle* _internal_mutable_angle();
  public:
  void unsafe_arena_set_allocated_angle(
      ::CMsgQAngle* angle);
  ::CMsgQAngle* unsafe_arena_release_angle();

  // optional bool relative = 1;
  bool has_relative() const;
  private:
  bool _internal_has_relative() const;
  public:
  void clear_relative();
  bool relative() const;
  void set_relative(bool value);
  private:
  bool _internal_relative() const;
  void _internal_set_relative(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_FixAngle)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::CMsgQAngle* angle_;
    bool relative_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_CrosshairAngle final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_CrosshairAngle) */ {
 public:
  inline CSVCMsg_CrosshairAngle() : CSVCMsg_CrosshairAngle(nullptr) {}
  ~CSVCMsg_CrosshairAngle() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_CrosshairAngle(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_CrosshairAngle(const CSVCMsg_CrosshairAngle& from);
  CSVCMsg_CrosshairAngle(CSVCMsg_CrosshairAngle&& from) noexcept
    : CSVCMsg_CrosshairAngle() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_CrosshairAngle& operator=(const CSVCMsg_CrosshairAngle& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_CrosshairAngle& operator=(CSVCMsg_CrosshairAngle&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_CrosshairAngle& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_CrosshairAngle* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_CrosshairAngle*>(
               &_CSVCMsg_CrosshairAngle_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

  friend void swap(CSVCMsg_CrosshairAngle& a, CSVCMsg_CrosshairAngle& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_CrosshairAngle* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_CrosshairAngle* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_CrosshairAngle* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_CrosshairAngle>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_CrosshairAngle& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_CrosshairAngle& from) {
    CSVCMsg_CrosshairAngle::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_CrosshairAngle* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_CrosshairAngle";
  }
  protected:
  explicit CSVCMsg_CrosshairAngle(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAngleFieldNumber = 1,
  };
  // optional .CMsgQAngle angle = 1;
  bool has_angle() const;
  private:
  bool _internal_has_angle() const;
  public:
  void clear_angle();
  const ::CMsgQAngle& angle() const;
  PROTOBUF_NODISCARD ::CMsgQAngle* release_angle();
  ::CMsgQAngle* mutable_angle();
  void set_allocated_angle(::CMsgQAngle* angle);
  private:
  const ::CMsgQAngle& _internal_angle() const;
  ::CMsgQAngle* _internal_mutable_angle();
  public:
  void unsafe_arena_set_allocated_angle(
      ::CMsgQAngle* angle);
  ::CMsgQAngle* unsafe_arena_release_angle();

  // @@protoc_insertion_point(class_scope:CSVCMsg_CrosshairAngle)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::CMsgQAngle* angle_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_BSPDecal final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_BSPDecal) */ {
 public:
  inline CSVCMsg_BSPDecal() : CSVCMsg_BSPDecal(nullptr) {}
  ~CSVCMsg_BSPDecal() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_BSPDecal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_BSPDecal(const CSVCMsg_BSPDecal& from);
  CSVCMsg_BSPDecal(CSVCMsg_BSPDecal&& from) noexcept
    : CSVCMsg_BSPDecal() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_BSPDecal& operator=(const CSVCMsg_BSPDecal& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_BSPDecal& operator=(CSVCMsg_BSPDecal&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_BSPDecal& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_BSPDecal* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_BSPDecal*>(
               &_CSVCMsg_BSPDecal_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    27;

  friend void swap(CSVCMsg_BSPDecal& a, CSVCMsg_BSPDecal& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_BSPDecal* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_BSPDecal* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_BSPDecal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_BSPDecal>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_BSPDecal& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_BSPDecal& from) {
    CSVCMsg_BSPDecal::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_BSPDecal* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_BSPDecal";
  }
  protected:
  explicit CSVCMsg_BSPDecal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPosFieldNumber = 1,
    kDecalTextureIndexFieldNumber = 2,
    kModelIndexFieldNumber = 4,
    kLowPriorityFieldNumber = 5,
    kEntityIndexFieldNumber = 3,
  };
  // optional .CMsgVector pos = 1;
  bool has_pos() const;
  private:
  bool _internal_has_pos() const;
  public:
  void clear_pos();
  const ::CMsgVector& pos() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_pos();
  ::CMsgVector* mutable_pos();
  void set_allocated_pos(::CMsgVector* pos);
  private:
  const ::CMsgVector& _internal_pos() const;
  ::CMsgVector* _internal_mutable_pos();
  public:
  void unsafe_arena_set_allocated_pos(
      ::CMsgVector* pos);
  ::CMsgVector* unsafe_arena_release_pos();

  // optional int32 decal_texture_index = 2;
  bool has_decal_texture_index() const;
  private:
  bool _internal_has_decal_texture_index() const;
  public:
  void clear_decal_texture_index();
  int32_t decal_texture_index() const;
  void set_decal_texture_index(int32_t value);
  private:
  int32_t _internal_decal_texture_index() const;
  void _internal_set_decal_texture_index(int32_t value);
  public:

  // optional int32 model_index = 4;
  bool has_model_index() const;
  private:
  bool _internal_has_model_index() const;
  public:
  void clear_model_index();
  int32_t model_index() const;
  void set_model_index(int32_t value);
  private:
  int32_t _internal_model_index() const;
  void _internal_set_model_index(int32_t value);
  public:

  // optional bool low_priority = 5;
  bool has_low_priority() const;
  private:
  bool _internal_has_low_priority() const;
  public:
  void clear_low_priority();
  bool low_priority() const;
  void set_low_priority(bool value);
  private:
  bool _internal_low_priority() const;
  void _internal_set_low_priority(bool value);
  public:

  // optional int32 entity_index = 3 [default = -1];
  bool has_entity_index() const;
  private:
  bool _internal_has_entity_index() const;
  public:
  void clear_entity_index();
  int32_t entity_index() const;
  void set_entity_index(int32_t value);
  private:
  int32_t _internal_entity_index() const;
  void _internal_set_entity_index(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_BSPDecal)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::CMsgVector* pos_;
    int32_t decal_texture_index_;
    int32_t model_index_;
    bool low_priority_;
    int32_t entity_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_SplitScreen final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_SplitScreen) */ {
 public:
  inline CSVCMsg_SplitScreen() : CSVCMsg_SplitScreen(nullptr) {}
  ~CSVCMsg_SplitScreen() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_SplitScreen(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_SplitScreen(const CSVCMsg_SplitScreen& from);
  CSVCMsg_SplitScreen(CSVCMsg_SplitScreen&& from) noexcept
    : CSVCMsg_SplitScreen() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_SplitScreen& operator=(const CSVCMsg_SplitScreen& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_SplitScreen& operator=(CSVCMsg_SplitScreen&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_SplitScreen& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_SplitScreen* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_SplitScreen*>(
               &_CSVCMsg_SplitScreen_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    28;

  friend void swap(CSVCMsg_SplitScreen& a, CSVCMsg_SplitScreen& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_SplitScreen* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_SplitScreen* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_SplitScreen* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_SplitScreen>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_SplitScreen& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_SplitScreen& from) {
    CSVCMsg_SplitScreen::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_SplitScreen* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_SplitScreen";
  }
  protected:
  explicit CSVCMsg_SplitScreen(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTypeFieldNumber = 1,
    kSlotFieldNumber = 2,
    kPlayerIndexFieldNumber = 3,
  };
  // optional .ESplitScreenMessageType type = 1 [default = MSG_SPLITSCREEN_ADDUSER];
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::ESplitScreenMessageType type() const;
  void set_type(::ESplitScreenMessageType value);
  private:
  ::ESplitScreenMessageType _internal_type() const;
  void _internal_set_type(::ESplitScreenMessageType value);
  public:

  // optional int32 slot = 2;
  bool has_slot() const;
  private:
  bool _internal_has_slot() const;
  public:
  void clear_slot();
  int32_t slot() const;
  void set_slot(int32_t value);
  private:
  int32_t _internal_slot() const;
  void _internal_set_slot(int32_t value);
  public:

  // optional int32 player_index = 3 [default = -1];
  bool has_player_index() const;
  private:
  bool _internal_has_player_index() const;
  public:
  void clear_player_index();
  int32_t player_index() const;
  void set_player_index(int32_t value);
  private:
  int32_t _internal_player_index() const;
  void _internal_set_player_index(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_SplitScreen)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int type_;
    int32_t slot_;
    int32_t player_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_GetCvarValue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_GetCvarValue) */ {
 public:
  inline CSVCMsg_GetCvarValue() : CSVCMsg_GetCvarValue(nullptr) {}
  ~CSVCMsg_GetCvarValue() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_GetCvarValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_GetCvarValue(const CSVCMsg_GetCvarValue& from);
  CSVCMsg_GetCvarValue(CSVCMsg_GetCvarValue&& from) noexcept
    : CSVCMsg_GetCvarValue() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_GetCvarValue& operator=(const CSVCMsg_GetCvarValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_GetCvarValue& operator=(CSVCMsg_GetCvarValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_GetCvarValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_GetCvarValue* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_GetCvarValue*>(
               &_CSVCMsg_GetCvarValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    29;

  friend void swap(CSVCMsg_GetCvarValue& a, CSVCMsg_GetCvarValue& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_GetCvarValue* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_GetCvarValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_GetCvarValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_GetCvarValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_GetCvarValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_GetCvarValue& from) {
    CSVCMsg_GetCvarValue::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_GetCvarValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_GetCvarValue";
  }
  protected:
  explicit CSVCMsg_GetCvarValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCvarNameFieldNumber = 2,
    kCookieFieldNumber = 1,
  };
  // optional string cvar_name = 2;
  bool has_cvar_name() const;
  private:
  bool _internal_has_cvar_name() const;
  public:
  void clear_cvar_name();
  const std::string& cvar_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_cvar_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_cvar_name();
  PROTOBUF_NODISCARD std::string* release_cvar_name();
  void set_allocated_cvar_name(std::string* cvar_name);
  private:
  const std::string& _internal_cvar_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cvar_name(const std::string& value);
  std::string* _internal_mutable_cvar_name();
  public:

  // optional int32 cookie = 1;
  bool has_cookie() const;
  private:
  bool _internal_has_cookie() const;
  public:
  void clear_cookie();
  int32_t cookie() const;
  void set_cookie(int32_t value);
  private:
  int32_t _internal_cookie() const;
  void _internal_set_cookie(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_GetCvarValue)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cvar_name_;
    int32_t cookie_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_Menu final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_Menu) */ {
 public:
  inline CSVCMsg_Menu() : CSVCMsg_Menu(nullptr) {}
  ~CSVCMsg_Menu() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_Menu(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_Menu(const CSVCMsg_Menu& from);
  CSVCMsg_Menu(CSVCMsg_Menu&& from) noexcept
    : CSVCMsg_Menu() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_Menu& operator=(const CSVCMsg_Menu& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_Menu& operator=(CSVCMsg_Menu&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_Menu& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_Menu* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_Menu*>(
               &_CSVCMsg_Menu_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    30;

  friend void swap(CSVCMsg_Menu& a, CSVCMsg_Menu& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_Menu* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_Menu* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_Menu* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_Menu>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_Menu& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_Menu& from) {
    CSVCMsg_Menu::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_Menu* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_Menu";
  }
  protected:
  explicit CSVCMsg_Menu(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMenuKeyValuesFieldNumber = 2,
    kDialogTypeFieldNumber = 1,
  };
  // optional bytes menu_key_values = 2;
  bool has_menu_key_values() const;
  private:
  bool _internal_has_menu_key_values() const;
  public:
  void clear_menu_key_values();
  const std::string& menu_key_values() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_menu_key_values(ArgT0&& arg0, ArgT... args);
  std::string* mutable_menu_key_values();
  PROTOBUF_NODISCARD std::string* release_menu_key_values();
  void set_allocated_menu_key_values(std::string* menu_key_values);
  private:
  const std::string& _internal_menu_key_values() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_menu_key_values(const std::string& value);
  std::string* _internal_mutable_menu_key_values();
  public:

  // optional int32 dialog_type = 1;
  bool has_dialog_type() const;
  private:
  bool _internal_has_dialog_type() const;
  public:
  void clear_dialog_type();
  int32_t dialog_type() const;
  void set_dialog_type(int32_t value);
  private:
  int32_t _internal_dialog_type() const;
  void _internal_set_dialog_type(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_Menu)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr menu_key_values_;
    int32_t dialog_type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_UserMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_UserMessage) */ {
 public:
  inline CSVCMsg_UserMessage() : CSVCMsg_UserMessage(nullptr) {}
  ~CSVCMsg_UserMessage() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_UserMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_UserMessage(const CSVCMsg_UserMessage& from);
  CSVCMsg_UserMessage(CSVCMsg_UserMessage&& from) noexcept
    : CSVCMsg_UserMessage() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_UserMessage& operator=(const CSVCMsg_UserMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_UserMessage& operator=(CSVCMsg_UserMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_UserMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_UserMessage* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_UserMessage*>(
               &_CSVCMsg_UserMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    31;

  friend void swap(CSVCMsg_UserMessage& a, CSVCMsg_UserMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_UserMessage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_UserMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_UserMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_UserMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_UserMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_UserMessage& from) {
    CSVCMsg_UserMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_UserMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_UserMessage";
  }
  protected:
  explicit CSVCMsg_UserMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMsgDataFieldNumber = 2,
    kMsgTypeFieldNumber = 1,
    kPassthroughFieldNumber = 3,
  };
  // optional bytes msg_data = 2;
  bool has_msg_data() const;
  private:
  bool _internal_has_msg_data() const;
  public:
  void clear_msg_data();
  const std::string& msg_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_msg_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_msg_data();
  PROTOBUF_NODISCARD std::string* release_msg_data();
  void set_allocated_msg_data(std::string* msg_data);
  private:
  const std::string& _internal_msg_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_msg_data(const std::string& value);
  std::string* _internal_mutable_msg_data();
  public:

  // optional int32 msg_type = 1;
  bool has_msg_type() const;
  private:
  bool _internal_has_msg_type() const;
  public:
  void clear_msg_type();
  int32_t msg_type() const;
  void set_msg_type(int32_t value);
  private:
  int32_t _internal_msg_type() const;
  void _internal_set_msg_type(int32_t value);
  public:

  // optional int32 passthrough = 3;
  bool has_passthrough() const;
  private:
  bool _internal_has_passthrough() const;
  public:
  void clear_passthrough();
  int32_t passthrough() const;
  void set_passthrough(int32_t value);
  private:
  int32_t _internal_passthrough() const;
  void _internal_set_passthrough(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_UserMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msg_data_;
    int32_t msg_type_;
    int32_t passthrough_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_SendTable_sendprop_t final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_SendTable.sendprop_t) */ {
 public:
  inline CSVCMsg_SendTable_sendprop_t() : CSVCMsg_SendTable_sendprop_t(nullptr) {}
  ~CSVCMsg_SendTable_sendprop_t() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_SendTable_sendprop_t(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_SendTable_sendprop_t(const CSVCMsg_SendTable_sendprop_t& from);
  CSVCMsg_SendTable_sendprop_t(CSVCMsg_SendTable_sendprop_t&& from) noexcept
    : CSVCMsg_SendTable_sendprop_t() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_SendTable_sendprop_t& operator=(const CSVCMsg_SendTable_sendprop_t& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_SendTable_sendprop_t& operator=(CSVCMsg_SendTable_sendprop_t&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_SendTable_sendprop_t& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_SendTable_sendprop_t* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_SendTable_sendprop_t*>(
               &_CSVCMsg_SendTable_sendprop_t_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    32;

  friend void swap(CSVCMsg_SendTable_sendprop_t& a, CSVCMsg_SendTable_sendprop_t& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_SendTable_sendprop_t* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_SendTable_sendprop_t* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_SendTable_sendprop_t* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_SendTable_sendprop_t>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_SendTable_sendprop_t& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_SendTable_sendprop_t& from) {
    CSVCMsg_SendTable_sendprop_t::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_SendTable_sendprop_t* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_SendTable.sendprop_t";
  }
  protected:
  explicit CSVCMsg_SendTable_sendprop_t(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kVarNameFieldNumber = 2,
    kDtNameFieldNumber = 5,
    kTypeFieldNumber = 1,
    kFlagsFieldNumber = 3,
    kPriorityFieldNumber = 4,
    kNumElementsFieldNumber = 6,
    kLowValueFieldNumber = 7,
    kHighValueFieldNumber = 8,
    kNumBitsFieldNumber = 9,
  };
  // optional string var_name = 2;
  bool has_var_name() const;
  private:
  bool _internal_has_var_name() const;
  public:
  void clear_var_name();
  const std::string& var_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_var_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_var_name();
  PROTOBUF_NODISCARD std::string* release_var_name();
  void set_allocated_var_name(std::string* var_name);
  private:
  const std::string& _internal_var_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_var_name(const std::string& value);
  std::string* _internal_mutable_var_name();
  public:

  // optional string dt_name = 5;
  bool has_dt_name() const;
  private:
  bool _internal_has_dt_name() const;
  public:
  void clear_dt_name();
  const std::string& dt_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_dt_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_dt_name();
  PROTOBUF_NODISCARD std::string* release_dt_name();
  void set_allocated_dt_name(std::string* dt_name);
  private:
  const std::string& _internal_dt_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dt_name(const std::string& value);
  std::string* _internal_mutable_dt_name();
  public:

  // optional int32 type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  int32_t type() const;
  void set_type(int32_t value);
  private:
  int32_t _internal_type() const;
  void _internal_set_type(int32_t value);
  public:

  // optional int32 flags = 3;
  bool has_flags() const;
  private:
  bool _internal_has_flags() const;
  public:
  void clear_flags();
  int32_t flags() const;
  void set_flags(int32_t value);
  private:
  int32_t _internal_flags() const;
  void _internal_set_flags(int32_t value);
  public:

  // optional int32 priority = 4;
  bool has_priority() const;
  private:
  bool _internal_has_priority() const;
  public:
  void clear_priority();
  int32_t priority() const;
  void set_priority(int32_t value);
  private:
  int32_t _internal_priority() const;
  void _internal_set_priority(int32_t value);
  public:

  // optional int32 num_elements = 6;
  bool has_num_elements() const;
  private:
  bool _internal_has_num_elements() const;
  public:
  void clear_num_elements();
  int32_t num_elements() const;
  void set_num_elements(int32_t value);
  private:
  int32_t _internal_num_elements() const;
  void _internal_set_num_elements(int32_t value);
  public:

  // optional float low_value = 7;
  bool has_low_value() const;
  private:
  bool _internal_has_low_value() const;
  public:
  void clear_low_value();
  float low_value() const;
  void set_low_value(float value);
  private:
  float _internal_low_value() const;
  void _internal_set_low_value(float value);
  public:

  // optional float high_value = 8;
  bool has_high_value() const;
  private:
  bool _internal_has_high_value() const;
  public:
  void clear_high_value();
  float high_value() const;
  void set_high_value(float value);
  private:
  float _internal_high_value() const;
  void _internal_set_high_value(float value);
  public:

  // optional int32 num_bits = 9;
  bool has_num_bits() const;
  private:
  bool _internal_has_num_bits() const;
  public:
  void clear_num_bits();
  int32_t num_bits() const;
  void set_num_bits(int32_t value);
  private:
  int32_t _internal_num_bits() const;
  void _internal_set_num_bits(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_SendTable.sendprop_t)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr var_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dt_name_;
    int32_t type_;
    int32_t flags_;
    int32_t priority_;
    int32_t num_elements_;
    float low_value_;
    float high_value_;
    int32_t num_bits_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_SendTable final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_SendTable) */ {
 public:
  inline CSVCMsg_SendTable() : CSVCMsg_SendTable(nullptr) {}
  ~CSVCMsg_SendTable() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_SendTable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_SendTable(const CSVCMsg_SendTable& from);
  CSVCMsg_SendTable(CSVCMsg_SendTable&& from) noexcept
    : CSVCMsg_SendTable() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_SendTable& operator=(const CSVCMsg_SendTable& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_SendTable& operator=(CSVCMsg_SendTable&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_SendTable& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_SendTable* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_SendTable*>(
               &_CSVCMsg_SendTable_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    33;

  friend void swap(CSVCMsg_SendTable& a, CSVCMsg_SendTable& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_SendTable* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_SendTable* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_SendTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_SendTable>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_SendTable& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_SendTable& from) {
    CSVCMsg_SendTable::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_SendTable* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_SendTable";
  }
  protected:
  explicit CSVCMsg_SendTable(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef CSVCMsg_SendTable_sendprop_t sendprop_t;

  // accessors -------------------------------------------------------

  enum : int {
    kPropsFieldNumber = 4,
    kNetTableNameFieldNumber = 2,
    kIsEndFieldNumber = 1,
    kNeedsDecoderFieldNumber = 3,
  };
  // repeated .CSVCMsg_SendTable.sendprop_t props = 4;
  int props_size() const;
  private:
  int _internal_props_size() const;
  public:
  void clear_props();
  ::CSVCMsg_SendTable_sendprop_t* mutable_props(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_SendTable_sendprop_t >*
      mutable_props();
  private:
  const ::CSVCMsg_SendTable_sendprop_t& _internal_props(int index) const;
  ::CSVCMsg_SendTable_sendprop_t* _internal_add_props();
  public:
  const ::CSVCMsg_SendTable_sendprop_t& props(int index) const;
  ::CSVCMsg_SendTable_sendprop_t* add_props();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_SendTable_sendprop_t >&
      props() const;

  // optional string net_table_name = 2;
  bool has_net_table_name() const;
  private:
  bool _internal_has_net_table_name() const;
  public:
  void clear_net_table_name();
  const std::string& net_table_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_net_table_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_net_table_name();
  PROTOBUF_NODISCARD std::string* release_net_table_name();
  void set_allocated_net_table_name(std::string* net_table_name);
  private:
  const std::string& _internal_net_table_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_net_table_name(const std::string& value);
  std::string* _internal_mutable_net_table_name();
  public:

  // optional bool is_end = 1;
  bool has_is_end() const;
  private:
  bool _internal_has_is_end() const;
  public:
  void clear_is_end();
  bool is_end() const;
  void set_is_end(bool value);
  private:
  bool _internal_is_end() const;
  void _internal_set_is_end(bool value);
  public:

  // optional bool needs_decoder = 3;
  bool has_needs_decoder() const;
  private:
  bool _internal_has_needs_decoder() const;
  public:
  void clear_needs_decoder();
  bool needs_decoder() const;
  void set_needs_decoder(bool value);
  private:
  bool _internal_needs_decoder() const;
  void _internal_set_needs_decoder(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_SendTable)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_SendTable_sendprop_t > props_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr net_table_name_;
    bool is_end_;
    bool needs_decoder_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_GameEventList_key_t final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_GameEventList.key_t) */ {
 public:
  inline CSVCMsg_GameEventList_key_t() : CSVCMsg_GameEventList_key_t(nullptr) {}
  ~CSVCMsg_GameEventList_key_t() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_GameEventList_key_t(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_GameEventList_key_t(const CSVCMsg_GameEventList_key_t& from);
  CSVCMsg_GameEventList_key_t(CSVCMsg_GameEventList_key_t&& from) noexcept
    : CSVCMsg_GameEventList_key_t() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_GameEventList_key_t& operator=(const CSVCMsg_GameEventList_key_t& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_GameEventList_key_t& operator=(CSVCMsg_GameEventList_key_t&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_GameEventList_key_t& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_GameEventList_key_t* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_GameEventList_key_t*>(
               &_CSVCMsg_GameEventList_key_t_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    34;

  friend void swap(CSVCMsg_GameEventList_key_t& a, CSVCMsg_GameEventList_key_t& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_GameEventList_key_t* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_GameEventList_key_t* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_GameEventList_key_t* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_GameEventList_key_t>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_GameEventList_key_t& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_GameEventList_key_t& from) {
    CSVCMsg_GameEventList_key_t::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_GameEventList_key_t* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_GameEventList.key_t";
  }
  protected:
  explicit CSVCMsg_GameEventList_key_t(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 2,
    kTypeFieldNumber = 1,
  };
  // optional string name = 2;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // optional int32 type = 1;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  int32_t type() const;
  void set_type(int32_t value);
  private:
  int32_t _internal_type() const;
  void _internal_set_type(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_GameEventList.key_t)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    int32_t type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_GameEventList_descriptor_t final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_GameEventList.descriptor_t) */ {
 public:
  inline CSVCMsg_GameEventList_descriptor_t() : CSVCMsg_GameEventList_descriptor_t(nullptr) {}
  ~CSVCMsg_GameEventList_descriptor_t() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_GameEventList_descriptor_t(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_GameEventList_descriptor_t(const CSVCMsg_GameEventList_descriptor_t& from);
  CSVCMsg_GameEventList_descriptor_t(CSVCMsg_GameEventList_descriptor_t&& from) noexcept
    : CSVCMsg_GameEventList_descriptor_t() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_GameEventList_descriptor_t& operator=(const CSVCMsg_GameEventList_descriptor_t& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_GameEventList_descriptor_t& operator=(CSVCMsg_GameEventList_descriptor_t&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_GameEventList_descriptor_t& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_GameEventList_descriptor_t* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_GameEventList_descriptor_t*>(
               &_CSVCMsg_GameEventList_descriptor_t_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    35;

  friend void swap(CSVCMsg_GameEventList_descriptor_t& a, CSVCMsg_GameEventList_descriptor_t& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_GameEventList_descriptor_t* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_GameEventList_descriptor_t* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_GameEventList_descriptor_t* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_GameEventList_descriptor_t>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_GameEventList_descriptor_t& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_GameEventList_descriptor_t& from) {
    CSVCMsg_GameEventList_descriptor_t::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_GameEventList_descriptor_t* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_GameEventList.descriptor_t";
  }
  protected:
  explicit CSVCMsg_GameEventList_descriptor_t(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKeysFieldNumber = 3,
    kNameFieldNumber = 2,
    kEventidFieldNumber = 1,
  };
  // repeated .CSVCMsg_GameEventList.key_t keys = 3;
  int keys_size() const;
  private:
  int _internal_keys_size() const;
  public:
  void clear_keys();
  ::CSVCMsg_GameEventList_key_t* mutable_keys(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_GameEventList_key_t >*
      mutable_keys();
  private:
  const ::CSVCMsg_GameEventList_key_t& _internal_keys(int index) const;
  ::CSVCMsg_GameEventList_key_t* _internal_add_keys();
  public:
  const ::CSVCMsg_GameEventList_key_t& keys(int index) const;
  ::CSVCMsg_GameEventList_key_t* add_keys();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_GameEventList_key_t >&
      keys() const;

  // optional string name = 2;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // optional int32 eventid = 1;
  bool has_eventid() const;
  private:
  bool _internal_has_eventid() const;
  public:
  void clear_eventid();
  int32_t eventid() const;
  void set_eventid(int32_t value);
  private:
  int32_t _internal_eventid() const;
  void _internal_set_eventid(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_GameEventList.descriptor_t)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_GameEventList_key_t > keys_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    int32_t eventid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_GameEventList final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_GameEventList) */ {
 public:
  inline CSVCMsg_GameEventList() : CSVCMsg_GameEventList(nullptr) {}
  ~CSVCMsg_GameEventList() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_GameEventList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_GameEventList(const CSVCMsg_GameEventList& from);
  CSVCMsg_GameEventList(CSVCMsg_GameEventList&& from) noexcept
    : CSVCMsg_GameEventList() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_GameEventList& operator=(const CSVCMsg_GameEventList& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_GameEventList& operator=(CSVCMsg_GameEventList&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_GameEventList& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_GameEventList* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_GameEventList*>(
               &_CSVCMsg_GameEventList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    36;

  friend void swap(CSVCMsg_GameEventList& a, CSVCMsg_GameEventList& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_GameEventList* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_GameEventList* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_GameEventList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_GameEventList>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_GameEventList& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_GameEventList& from) {
    CSVCMsg_GameEventList::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_GameEventList* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_GameEventList";
  }
  protected:
  explicit CSVCMsg_GameEventList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef CSVCMsg_GameEventList_key_t key_t;
  typedef CSVCMsg_GameEventList_descriptor_t descriptor_t;

  // accessors -------------------------------------------------------

  enum : int {
    kDescriptorsFieldNumber = 1,
  };
  // repeated .CSVCMsg_GameEventList.descriptor_t descriptors = 1;
  int descriptors_size() const;
  private:
  int _internal_descriptors_size() const;
  public:
  void clear_descriptors();
  ::CSVCMsg_GameEventList_descriptor_t* mutable_descriptors(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_GameEventList_descriptor_t >*
      mutable_descriptors();
  private:
  const ::CSVCMsg_GameEventList_descriptor_t& _internal_descriptors(int index) const;
  ::CSVCMsg_GameEventList_descriptor_t* _internal_add_descriptors();
  public:
  const ::CSVCMsg_GameEventList_descriptor_t& descriptors(int index) const;
  ::CSVCMsg_GameEventList_descriptor_t* add_descriptors();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_GameEventList_descriptor_t >&
      descriptors() const;

  // @@protoc_insertion_point(class_scope:CSVCMsg_GameEventList)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_GameEventList_descriptor_t > descriptors_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_PacketEntities_alternate_baseline_t final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_PacketEntities.alternate_baseline_t) */ {
 public:
  inline CSVCMsg_PacketEntities_alternate_baseline_t() : CSVCMsg_PacketEntities_alternate_baseline_t(nullptr) {}
  ~CSVCMsg_PacketEntities_alternate_baseline_t() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_PacketEntities_alternate_baseline_t(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_PacketEntities_alternate_baseline_t(const CSVCMsg_PacketEntities_alternate_baseline_t& from);
  CSVCMsg_PacketEntities_alternate_baseline_t(CSVCMsg_PacketEntities_alternate_baseline_t&& from) noexcept
    : CSVCMsg_PacketEntities_alternate_baseline_t() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_PacketEntities_alternate_baseline_t& operator=(const CSVCMsg_PacketEntities_alternate_baseline_t& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_PacketEntities_alternate_baseline_t& operator=(CSVCMsg_PacketEntities_alternate_baseline_t&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_PacketEntities_alternate_baseline_t& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_PacketEntities_alternate_baseline_t* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_PacketEntities_alternate_baseline_t*>(
               &_CSVCMsg_PacketEntities_alternate_baseline_t_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    37;

  friend void swap(CSVCMsg_PacketEntities_alternate_baseline_t& a, CSVCMsg_PacketEntities_alternate_baseline_t& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_PacketEntities_alternate_baseline_t* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_PacketEntities_alternate_baseline_t* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_PacketEntities_alternate_baseline_t* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_PacketEntities_alternate_baseline_t>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_PacketEntities_alternate_baseline_t& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_PacketEntities_alternate_baseline_t& from) {
    CSVCMsg_PacketEntities_alternate_baseline_t::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_PacketEntities_alternate_baseline_t* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_PacketEntities.alternate_baseline_t";
  }
  protected:
  explicit CSVCMsg_PacketEntities_alternate_baseline_t(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEntityIndexFieldNumber = 1,
    kBaselineIndexFieldNumber = 2,
  };
  // optional int32 entity_index = 1;
  bool has_entity_index() const;
  private:
  bool _internal_has_entity_index() const;
  public:
  void clear_entity_index();
  int32_t entity_index() const;
  void set_entity_index(int32_t value);
  private:
  int32_t _internal_entity_index() const;
  void _internal_set_entity_index(int32_t value);
  public:

  // optional int32 baseline_index = 2;
  bool has_baseline_index() const;
  private:
  bool _internal_has_baseline_index() const;
  public:
  void clear_baseline_index();
  int32_t baseline_index() const;
  void set_baseline_index(int32_t value);
  private:
  int32_t _internal_baseline_index() const;
  void _internal_set_baseline_index(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_PacketEntities.alternate_baseline_t)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t entity_index_;
    int32_t baseline_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_PacketEntities_non_transmitted_entities_t final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_PacketEntities.non_transmitted_entities_t) */ {
 public:
  inline CSVCMsg_PacketEntities_non_transmitted_entities_t() : CSVCMsg_PacketEntities_non_transmitted_entities_t(nullptr) {}
  ~CSVCMsg_PacketEntities_non_transmitted_entities_t() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_PacketEntities_non_transmitted_entities_t(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_PacketEntities_non_transmitted_entities_t(const CSVCMsg_PacketEntities_non_transmitted_entities_t& from);
  CSVCMsg_PacketEntities_non_transmitted_entities_t(CSVCMsg_PacketEntities_non_transmitted_entities_t&& from) noexcept
    : CSVCMsg_PacketEntities_non_transmitted_entities_t() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_PacketEntities_non_transmitted_entities_t& operator=(const CSVCMsg_PacketEntities_non_transmitted_entities_t& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_PacketEntities_non_transmitted_entities_t& operator=(CSVCMsg_PacketEntities_non_transmitted_entities_t&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_PacketEntities_non_transmitted_entities_t& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_PacketEntities_non_transmitted_entities_t* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_PacketEntities_non_transmitted_entities_t*>(
               &_CSVCMsg_PacketEntities_non_transmitted_entities_t_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    38;

  friend void swap(CSVCMsg_PacketEntities_non_transmitted_entities_t& a, CSVCMsg_PacketEntities_non_transmitted_entities_t& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_PacketEntities_non_transmitted_entities_t* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_PacketEntities_non_transmitted_entities_t* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_PacketEntities_non_transmitted_entities_t* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_PacketEntities_non_transmitted_entities_t>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_PacketEntities_non_transmitted_entities_t& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_PacketEntities_non_transmitted_entities_t& from) {
    CSVCMsg_PacketEntities_non_transmitted_entities_t::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_PacketEntities_non_transmitted_entities_t* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_PacketEntities.non_transmitted_entities_t";
  }
  protected:
  explicit CSVCMsg_PacketEntities_non_transmitted_entities_t(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 2,
    kHeaderCountFieldNumber = 1,
  };
  // optional bytes data = 2;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // optional int32 header_count = 1;
  bool has_header_count() const;
  private:
  bool _internal_has_header_count() const;
  public:
  void clear_header_count();
  int32_t header_count() const;
  void set_header_count(int32_t value);
  private:
  int32_t _internal_header_count() const;
  void _internal_set_header_count(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_PacketEntities.non_transmitted_entities_t)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    int32_t header_count_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_PacketEntities_outofpvs_entity_updates_t final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_PacketEntities.outofpvs_entity_updates_t) */ {
 public:
  inline CSVCMsg_PacketEntities_outofpvs_entity_updates_t() : CSVCMsg_PacketEntities_outofpvs_entity_updates_t(nullptr) {}
  ~CSVCMsg_PacketEntities_outofpvs_entity_updates_t() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_PacketEntities_outofpvs_entity_updates_t(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_PacketEntities_outofpvs_entity_updates_t(const CSVCMsg_PacketEntities_outofpvs_entity_updates_t& from);
  CSVCMsg_PacketEntities_outofpvs_entity_updates_t(CSVCMsg_PacketEntities_outofpvs_entity_updates_t&& from) noexcept
    : CSVCMsg_PacketEntities_outofpvs_entity_updates_t() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_PacketEntities_outofpvs_entity_updates_t& operator=(const CSVCMsg_PacketEntities_outofpvs_entity_updates_t& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_PacketEntities_outofpvs_entity_updates_t& operator=(CSVCMsg_PacketEntities_outofpvs_entity_updates_t&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_PacketEntities_outofpvs_entity_updates_t& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_PacketEntities_outofpvs_entity_updates_t* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_PacketEntities_outofpvs_entity_updates_t*>(
               &_CSVCMsg_PacketEntities_outofpvs_entity_updates_t_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    39;

  friend void swap(CSVCMsg_PacketEntities_outofpvs_entity_updates_t& a, CSVCMsg_PacketEntities_outofpvs_entity_updates_t& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_PacketEntities_outofpvs_entity_updates_t* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_PacketEntities_outofpvs_entity_updates_t* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_PacketEntities_outofpvs_entity_updates_t* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_PacketEntities_outofpvs_entity_updates_t>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_PacketEntities_outofpvs_entity_updates_t& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_PacketEntities_outofpvs_entity_updates_t& from) {
    CSVCMsg_PacketEntities_outofpvs_entity_updates_t::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_PacketEntities_outofpvs_entity_updates_t* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_PacketEntities.outofpvs_entity_updates_t";
  }
  protected:
  explicit CSVCMsg_PacketEntities_outofpvs_entity_updates_t(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 2,
    kCountFieldNumber = 1,
  };
  // optional bytes data = 2;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // optional int32 count = 1;
  bool has_count() const;
  private:
  bool _internal_has_count() const;
  public:
  void clear_count();
  int32_t count() const;
  void set_count(int32_t value);
  private:
  int32_t _internal_count() const;
  void _internal_set_count(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_PacketEntities.outofpvs_entity_updates_t)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    int32_t count_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_PacketEntities final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_PacketEntities) */ {
 public:
  inline CSVCMsg_PacketEntities() : CSVCMsg_PacketEntities(nullptr) {}
  ~CSVCMsg_PacketEntities() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_PacketEntities(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_PacketEntities(const CSVCMsg_PacketEntities& from);
  CSVCMsg_PacketEntities(CSVCMsg_PacketEntities&& from) noexcept
    : CSVCMsg_PacketEntities() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_PacketEntities& operator=(const CSVCMsg_PacketEntities& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_PacketEntities& operator=(CSVCMsg_PacketEntities&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_PacketEntities& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_PacketEntities* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_PacketEntities*>(
               &_CSVCMsg_PacketEntities_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    40;

  friend void swap(CSVCMsg_PacketEntities& a, CSVCMsg_PacketEntities& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_PacketEntities* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_PacketEntities* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_PacketEntities* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_PacketEntities>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_PacketEntities& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_PacketEntities& from) {
    CSVCMsg_PacketEntities::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_PacketEntities* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_PacketEntities";
  }
  protected:
  explicit CSVCMsg_PacketEntities(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef CSVCMsg_PacketEntities_alternate_baseline_t alternate_baseline_t;
  typedef CSVCMsg_PacketEntities_non_transmitted_entities_t non_transmitted_entities_t;
  typedef CSVCMsg_PacketEntities_outofpvs_entity_updates_t outofpvs_entity_updates_t;

  // accessors -------------------------------------------------------

  enum : int {
    kAlternateBaselinesFieldNumber = 15,
    kCmdRecvStatusFieldNumber = 22,
    kEntityDataFieldNumber = 7,
    kSerializedEntitiesFieldNumber = 13,
    kDevPaddingFieldNumber = 999,
    kNonTransmittedEntitiesFieldNumber = 19,
    kOutofpvsEntityUpdatesFieldNumber = 23,
    kMaxEntriesFieldNumber = 1,
    kUpdatedEntriesFieldNumber = 2,
    kBaselineFieldNumber = 5,
    kLegacyIsDeltaFieldNumber = 3,
    kUpdateBaselineFieldNumber = 4,
    kPendingFullFrameFieldNumber = 8,
    kDeltaFromFieldNumber = 6,
    kActiveSpawngroupHandleFieldNumber = 9,
    kMaxSpawngroupCreationsequenceFieldNumber = 10,
    kLastCmdNumberExecutedFieldNumber = 11,
    kServerTickFieldNumber = 12,
    kHasPvsVisBitsDeprecatedFieldNumber = 16,
    kLastCmdNumberRecvDeltaFieldNumber = 17,
    kCqStarvedCommandTicksFieldNumber = 20,
    kCqDiscardedCommandTicksFieldNumber = 21,
  };
  // repeated .CSVCMsg_PacketEntities.alternate_baseline_t alternate_baselines = 15;
  int alternate_baselines_size() const;
  private:
  int _internal_alternate_baselines_size() const;
  public:
  void clear_alternate_baselines();
  ::CSVCMsg_PacketEntities_alternate_baseline_t* mutable_alternate_baselines(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_PacketEntities_alternate_baseline_t >*
      mutable_alternate_baselines();
  private:
  const ::CSVCMsg_PacketEntities_alternate_baseline_t& _internal_alternate_baselines(int index) const;
  ::CSVCMsg_PacketEntities_alternate_baseline_t* _internal_add_alternate_baselines();
  public:
  const ::CSVCMsg_PacketEntities_alternate_baseline_t& alternate_baselines(int index) const;
  ::CSVCMsg_PacketEntities_alternate_baseline_t* add_alternate_baselines();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_PacketEntities_alternate_baseline_t >&
      alternate_baselines() const;

  // repeated sint32 cmd_recv_status = 22 [packed = true];
  int cmd_recv_status_size() const;
  private:
  int _internal_cmd_recv_status_size() const;
  public:
  void clear_cmd_recv_status();
  private:
  int32_t _internal_cmd_recv_status(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_cmd_recv_status() const;
  void _internal_add_cmd_recv_status(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_cmd_recv_status();
  public:
  int32_t cmd_recv_status(int index) const;
  void set_cmd_recv_status(int index, int32_t value);
  void add_cmd_recv_status(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      cmd_recv_status() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_cmd_recv_status();

  // optional bytes entity_data = 7;
  bool has_entity_data() const;
  private:
  bool _internal_has_entity_data() const;
  public:
  void clear_entity_data();
  const std::string& entity_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_entity_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_entity_data();
  PROTOBUF_NODISCARD std::string* release_entity_data();
  void set_allocated_entity_data(std::string* entity_data);
  private:
  const std::string& _internal_entity_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_entity_data(const std::string& value);
  std::string* _internal_mutable_entity_data();
  public:

  // optional bytes serialized_entities = 13;
  bool has_serialized_entities() const;
  private:
  bool _internal_has_serialized_entities() const;
  public:
  void clear_serialized_entities();
  const std::string& serialized_entities() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_serialized_entities(ArgT0&& arg0, ArgT... args);
  std::string* mutable_serialized_entities();
  PROTOBUF_NODISCARD std::string* release_serialized_entities();
  void set_allocated_serialized_entities(std::string* serialized_entities);
  private:
  const std::string& _internal_serialized_entities() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_serialized_entities(const std::string& value);
  std::string* _internal_mutable_serialized_entities();
  public:

  // optional bytes dev_padding = 999;
  bool has_dev_padding() const;
  private:
  bool _internal_has_dev_padding() const;
  public:
  void clear_dev_padding();
  const std::string& dev_padding() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_dev_padding(ArgT0&& arg0, ArgT... args);
  std::string* mutable_dev_padding();
  PROTOBUF_NODISCARD std::string* release_dev_padding();
  void set_allocated_dev_padding(std::string* dev_padding);
  private:
  const std::string& _internal_dev_padding() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dev_padding(const std::string& value);
  std::string* _internal_mutable_dev_padding();
  public:

  // optional .CSVCMsg_PacketEntities.non_transmitted_entities_t non_transmitted_entities = 19;
  bool has_non_transmitted_entities() const;
  private:
  bool _internal_has_non_transmitted_entities() const;
  public:
  void clear_non_transmitted_entities();
  const ::CSVCMsg_PacketEntities_non_transmitted_entities_t& non_transmitted_entities() const;
  PROTOBUF_NODISCARD ::CSVCMsg_PacketEntities_non_transmitted_entities_t* release_non_transmitted_entities();
  ::CSVCMsg_PacketEntities_non_transmitted_entities_t* mutable_non_transmitted_entities();
  void set_allocated_non_transmitted_entities(::CSVCMsg_PacketEntities_non_transmitted_entities_t* non_transmitted_entities);
  private:
  const ::CSVCMsg_PacketEntities_non_transmitted_entities_t& _internal_non_transmitted_entities() const;
  ::CSVCMsg_PacketEntities_non_transmitted_entities_t* _internal_mutable_non_transmitted_entities();
  public:
  void unsafe_arena_set_allocated_non_transmitted_entities(
      ::CSVCMsg_PacketEntities_non_transmitted_entities_t* non_transmitted_entities);
  ::CSVCMsg_PacketEntities_non_transmitted_entities_t* unsafe_arena_release_non_transmitted_entities();

  // optional .CSVCMsg_PacketEntities.outofpvs_entity_updates_t outofpvs_entity_updates = 23;
  bool has_outofpvs_entity_updates() const;
  private:
  bool _internal_has_outofpvs_entity_updates() const;
  public:
  void clear_outofpvs_entity_updates();
  const ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t& outofpvs_entity_updates() const;
  PROTOBUF_NODISCARD ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* release_outofpvs_entity_updates();
  ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* mutable_outofpvs_entity_updates();
  void set_allocated_outofpvs_entity_updates(::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* outofpvs_entity_updates);
  private:
  const ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t& _internal_outofpvs_entity_updates() const;
  ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* _internal_mutable_outofpvs_entity_updates();
  public:
  void unsafe_arena_set_allocated_outofpvs_entity_updates(
      ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* outofpvs_entity_updates);
  ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* unsafe_arena_release_outofpvs_entity_updates();

  // optional int32 max_entries = 1;
  bool has_max_entries() const;
  private:
  bool _internal_has_max_entries() const;
  public:
  void clear_max_entries();
  int32_t max_entries() const;
  void set_max_entries(int32_t value);
  private:
  int32_t _internal_max_entries() const;
  void _internal_set_max_entries(int32_t value);
  public:

  // optional int32 updated_entries = 2;
  bool has_updated_entries() const;
  private:
  bool _internal_has_updated_entries() const;
  public:
  void clear_updated_entries();
  int32_t updated_entries() const;
  void set_updated_entries(int32_t value);
  private:
  int32_t _internal_updated_entries() const;
  void _internal_set_updated_entries(int32_t value);
  public:

  // optional int32 baseline = 5;
  bool has_baseline() const;
  private:
  bool _internal_has_baseline() const;
  public:
  void clear_baseline();
  int32_t baseline() const;
  void set_baseline(int32_t value);
  private:
  int32_t _internal_baseline() const;
  void _internal_set_baseline(int32_t value);
  public:

  // optional bool legacy_is_delta = 3;
  bool has_legacy_is_delta() const;
  private:
  bool _internal_has_legacy_is_delta() const;
  public:
  void clear_legacy_is_delta();
  bool legacy_is_delta() const;
  void set_legacy_is_delta(bool value);
  private:
  bool _internal_legacy_is_delta() const;
  void _internal_set_legacy_is_delta(bool value);
  public:

  // optional bool update_baseline = 4;
  bool has_update_baseline() const;
  private:
  bool _internal_has_update_baseline() const;
  public:
  void clear_update_baseline();
  bool update_baseline() const;
  void set_update_baseline(bool value);
  private:
  bool _internal_update_baseline() const;
  void _internal_set_update_baseline(bool value);
  public:

  // optional bool pending_full_frame = 8;
  bool has_pending_full_frame() const;
  private:
  bool _internal_has_pending_full_frame() const;
  public:
  void clear_pending_full_frame();
  bool pending_full_frame() const;
  void set_pending_full_frame(bool value);
  private:
  bool _internal_pending_full_frame() const;
  void _internal_set_pending_full_frame(bool value);
  public:

  // optional int32 delta_from = 6;
  bool has_delta_from() const;
  private:
  bool _internal_has_delta_from() const;
  public:
  void clear_delta_from();
  int32_t delta_from() const;
  void set_delta_from(int32_t value);
  private:
  int32_t _internal_delta_from() const;
  void _internal_set_delta_from(int32_t value);
  public:

  // optional uint32 active_spawngroup_handle = 9;
  bool has_active_spawngroup_handle() const;
  private:
  bool _internal_has_active_spawngroup_handle() const;
  public:
  void clear_active_spawngroup_handle();
  uint32_t active_spawngroup_handle() const;
  void set_active_spawngroup_handle(uint32_t value);
  private:
  uint32_t _internal_active_spawngroup_handle() const;
  void _internal_set_active_spawngroup_handle(uint32_t value);
  public:

  // optional uint32 max_spawngroup_creationsequence = 10;
  bool has_max_spawngroup_creationsequence() const;
  private:
  bool _internal_has_max_spawngroup_creationsequence() const;
  public:
  void clear_max_spawngroup_creationsequence();
  uint32_t max_spawngroup_creationsequence() const;
  void set_max_spawngroup_creationsequence(uint32_t value);
  private:
  uint32_t _internal_max_spawngroup_creationsequence() const;
  void _internal_set_max_spawngroup_creationsequence(uint32_t value);
  public:

  // optional uint32 last_cmd_number_executed = 11;
  bool has_last_cmd_number_executed() const;
  private:
  bool _internal_has_last_cmd_number_executed() const;
  public:
  void clear_last_cmd_number_executed();
  uint32_t last_cmd_number_executed() const;
  void set_last_cmd_number_executed(uint32_t value);
  private:
  uint32_t _internal_last_cmd_number_executed() const;
  void _internal_set_last_cmd_number_executed(uint32_t value);
  public:

  // optional uint32 server_tick = 12;
  bool has_server_tick() const;
  private:
  bool _internal_has_server_tick() const;
  public:
  void clear_server_tick();
  uint32_t server_tick() const;
  void set_server_tick(uint32_t value);
  private:
  uint32_t _internal_server_tick() const;
  void _internal_set_server_tick(uint32_t value);
  public:

  // optional uint32 has_pvs_vis_bits_deprecated = 16;
  bool has_has_pvs_vis_bits_deprecated() const;
  private:
  bool _internal_has_has_pvs_vis_bits_deprecated() const;
  public:
  void clear_has_pvs_vis_bits_deprecated();
  uint32_t has_pvs_vis_bits_deprecated() const;
  void set_has_pvs_vis_bits_deprecated(uint32_t value);
  private:
  uint32_t _internal_has_pvs_vis_bits_deprecated() const;
  void _internal_set_has_pvs_vis_bits_deprecated(uint32_t value);
  public:

  // optional sint32 last_cmd_number_recv_delta = 17;
  bool has_last_cmd_number_recv_delta() const;
  private:
  bool _internal_has_last_cmd_number_recv_delta() const;
  public:
  void clear_last_cmd_number_recv_delta();
  int32_t last_cmd_number_recv_delta() const;
  void set_last_cmd_number_recv_delta(int32_t value);
  private:
  int32_t _internal_last_cmd_number_recv_delta() const;
  void _internal_set_last_cmd_number_recv_delta(int32_t value);
  public:

  // optional uint32 cq_starved_command_ticks = 20;
  bool has_cq_starved_command_ticks() const;
  private:
  bool _internal_has_cq_starved_command_ticks() const;
  public:
  void clear_cq_starved_command_ticks();
  uint32_t cq_starved_command_ticks() const;
  void set_cq_starved_command_ticks(uint32_t value);
  private:
  uint32_t _internal_cq_starved_command_ticks() const;
  void _internal_set_cq_starved_command_ticks(uint32_t value);
  public:

  // optional uint32 cq_discarded_command_ticks = 21;
  bool has_cq_discarded_command_ticks() const;
  private:
  bool _internal_has_cq_discarded_command_ticks() const;
  public:
  void clear_cq_discarded_command_ticks();
  uint32_t cq_discarded_command_ticks() const;
  void set_cq_discarded_command_ticks(uint32_t value);
  private:
  uint32_t _internal_cq_discarded_command_ticks() const;
  void _internal_set_cq_discarded_command_ticks(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_PacketEntities)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_PacketEntities_alternate_baseline_t > alternate_baselines_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > cmd_recv_status_;
    mutable std::atomic<int> _cmd_recv_status_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entity_data_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serialized_entities_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dev_padding_;
    ::CSVCMsg_PacketEntities_non_transmitted_entities_t* non_transmitted_entities_;
    ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* outofpvs_entity_updates_;
    int32_t max_entries_;
    int32_t updated_entries_;
    int32_t baseline_;
    bool legacy_is_delta_;
    bool update_baseline_;
    bool pending_full_frame_;
    int32_t delta_from_;
    uint32_t active_spawngroup_handle_;
    uint32_t max_spawngroup_creationsequence_;
    uint32_t last_cmd_number_executed_;
    uint32_t server_tick_;
    uint32_t has_pvs_vis_bits_deprecated_;
    int32_t last_cmd_number_recv_delta_;
    uint32_t cq_starved_command_ticks_;
    uint32_t cq_discarded_command_ticks_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_TempEntities final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_TempEntities) */ {
 public:
  inline CSVCMsg_TempEntities() : CSVCMsg_TempEntities(nullptr) {}
  ~CSVCMsg_TempEntities() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_TempEntities(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_TempEntities(const CSVCMsg_TempEntities& from);
  CSVCMsg_TempEntities(CSVCMsg_TempEntities&& from) noexcept
    : CSVCMsg_TempEntities() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_TempEntities& operator=(const CSVCMsg_TempEntities& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_TempEntities& operator=(CSVCMsg_TempEntities&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_TempEntities& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_TempEntities* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_TempEntities*>(
               &_CSVCMsg_TempEntities_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    41;

  friend void swap(CSVCMsg_TempEntities& a, CSVCMsg_TempEntities& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_TempEntities* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_TempEntities* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_TempEntities* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_TempEntities>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_TempEntities& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_TempEntities& from) {
    CSVCMsg_TempEntities::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_TempEntities* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_TempEntities";
  }
  protected:
  explicit CSVCMsg_TempEntities(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEntityDataFieldNumber = 3,
    kReliableFieldNumber = 1,
    kNumEntriesFieldNumber = 2,
  };
  // optional bytes entity_data = 3;
  bool has_entity_data() const;
  private:
  bool _internal_has_entity_data() const;
  public:
  void clear_entity_data();
  const std::string& entity_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_entity_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_entity_data();
  PROTOBUF_NODISCARD std::string* release_entity_data();
  void set_allocated_entity_data(std::string* entity_data);
  private:
  const std::string& _internal_entity_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_entity_data(const std::string& value);
  std::string* _internal_mutable_entity_data();
  public:

  // optional bool reliable = 1;
  bool has_reliable() const;
  private:
  bool _internal_has_reliable() const;
  public:
  void clear_reliable();
  bool reliable() const;
  void set_reliable(bool value);
  private:
  bool _internal_reliable() const;
  void _internal_set_reliable(bool value);
  public:

  // optional int32 num_entries = 2;
  bool has_num_entries() const;
  private:
  bool _internal_has_num_entries() const;
  public:
  void clear_num_entries();
  int32_t num_entries() const;
  void set_num_entries(int32_t value);
  private:
  int32_t _internal_num_entries() const;
  void _internal_set_num_entries(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_TempEntities)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entity_data_;
    bool reliable_;
    int32_t num_entries_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_CreateStringTable final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_CreateStringTable) */ {
 public:
  inline CSVCMsg_CreateStringTable() : CSVCMsg_CreateStringTable(nullptr) {}
  ~CSVCMsg_CreateStringTable() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_CreateStringTable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_CreateStringTable(const CSVCMsg_CreateStringTable& from);
  CSVCMsg_CreateStringTable(CSVCMsg_CreateStringTable&& from) noexcept
    : CSVCMsg_CreateStringTable() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_CreateStringTable& operator=(const CSVCMsg_CreateStringTable& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_CreateStringTable& operator=(CSVCMsg_CreateStringTable&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_CreateStringTable& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_CreateStringTable* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_CreateStringTable*>(
               &_CSVCMsg_CreateStringTable_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    42;

  friend void swap(CSVCMsg_CreateStringTable& a, CSVCMsg_CreateStringTable& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_CreateStringTable* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_CreateStringTable* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_CreateStringTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_CreateStringTable>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_CreateStringTable& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_CreateStringTable& from) {
    CSVCMsg_CreateStringTable::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_CreateStringTable* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_CreateStringTable";
  }
  protected:
  explicit CSVCMsg_CreateStringTable(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kStringDataFieldNumber = 7,
    kNumEntriesFieldNumber = 2,
    kUserDataSizeFieldNumber = 4,
    kUserDataSizeBitsFieldNumber = 5,
    kFlagsFieldNumber = 6,
    kUserDataFixedSizeFieldNumber = 3,
    kDataCompressedFieldNumber = 9,
    kUsingVarintBitcountsFieldNumber = 10,
    kUncompressedSizeFieldNumber = 8,
  };
  // optional string name = 1;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // optional bytes string_data = 7;
  bool has_string_data() const;
  private:
  bool _internal_has_string_data() const;
  public:
  void clear_string_data();
  const std::string& string_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_string_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_string_data();
  PROTOBUF_NODISCARD std::string* release_string_data();
  void set_allocated_string_data(std::string* string_data);
  private:
  const std::string& _internal_string_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_data(const std::string& value);
  std::string* _internal_mutable_string_data();
  public:

  // optional int32 num_entries = 2;
  bool has_num_entries() const;
  private:
  bool _internal_has_num_entries() const;
  public:
  void clear_num_entries();
  int32_t num_entries() const;
  void set_num_entries(int32_t value);
  private:
  int32_t _internal_num_entries() const;
  void _internal_set_num_entries(int32_t value);
  public:

  // optional int32 user_data_size = 4;
  bool has_user_data_size() const;
  private:
  bool _internal_has_user_data_size() const;
  public:
  void clear_user_data_size();
  int32_t user_data_size() const;
  void set_user_data_size(int32_t value);
  private:
  int32_t _internal_user_data_size() const;
  void _internal_set_user_data_size(int32_t value);
  public:

  // optional int32 user_data_size_bits = 5;
  bool has_user_data_size_bits() const;
  private:
  bool _internal_has_user_data_size_bits() const;
  public:
  void clear_user_data_size_bits();
  int32_t user_data_size_bits() const;
  void set_user_data_size_bits(int32_t value);
  private:
  int32_t _internal_user_data_size_bits() const;
  void _internal_set_user_data_size_bits(int32_t value);
  public:

  // optional int32 flags = 6;
  bool has_flags() const;
  private:
  bool _internal_has_flags() const;
  public:
  void clear_flags();
  int32_t flags() const;
  void set_flags(int32_t value);
  private:
  int32_t _internal_flags() const;
  void _internal_set_flags(int32_t value);
  public:

  // optional bool user_data_fixed_size = 3;
  bool has_user_data_fixed_size() const;
  private:
  bool _internal_has_user_data_fixed_size() const;
  public:
  void clear_user_data_fixed_size();
  bool user_data_fixed_size() const;
  void set_user_data_fixed_size(bool value);
  private:
  bool _internal_user_data_fixed_size() const;
  void _internal_set_user_data_fixed_size(bool value);
  public:

  // optional bool data_compressed = 9;
  bool has_data_compressed() const;
  private:
  bool _internal_has_data_compressed() const;
  public:
  void clear_data_compressed();
  bool data_compressed() const;
  void set_data_compressed(bool value);
  private:
  bool _internal_data_compressed() const;
  void _internal_set_data_compressed(bool value);
  public:

  // optional bool using_varint_bitcounts = 10;
  bool has_using_varint_bitcounts() const;
  private:
  bool _internal_has_using_varint_bitcounts() const;
  public:
  void clear_using_varint_bitcounts();
  bool using_varint_bitcounts() const;
  void set_using_varint_bitcounts(bool value);
  private:
  bool _internal_using_varint_bitcounts() const;
  void _internal_set_using_varint_bitcounts(bool value);
  public:

  // optional int32 uncompressed_size = 8;
  bool has_uncompressed_size() const;
  private:
  bool _internal_has_uncompressed_size() const;
  public:
  void clear_uncompressed_size();
  int32_t uncompressed_size() const;
  void set_uncompressed_size(int32_t value);
  private:
  int32_t _internal_uncompressed_size() const;
  void _internal_set_uncompressed_size(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_CreateStringTable)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_data_;
    int32_t num_entries_;
    int32_t user_data_size_;
    int32_t user_data_size_bits_;
    int32_t flags_;
    bool user_data_fixed_size_;
    bool data_compressed_;
    bool using_varint_bitcounts_;
    int32_t uncompressed_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_UpdateStringTable final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_UpdateStringTable) */ {
 public:
  inline CSVCMsg_UpdateStringTable() : CSVCMsg_UpdateStringTable(nullptr) {}
  ~CSVCMsg_UpdateStringTable() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_UpdateStringTable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_UpdateStringTable(const CSVCMsg_UpdateStringTable& from);
  CSVCMsg_UpdateStringTable(CSVCMsg_UpdateStringTable&& from) noexcept
    : CSVCMsg_UpdateStringTable() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_UpdateStringTable& operator=(const CSVCMsg_UpdateStringTable& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_UpdateStringTable& operator=(CSVCMsg_UpdateStringTable&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_UpdateStringTable& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_UpdateStringTable* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_UpdateStringTable*>(
               &_CSVCMsg_UpdateStringTable_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    43;

  friend void swap(CSVCMsg_UpdateStringTable& a, CSVCMsg_UpdateStringTable& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_UpdateStringTable* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_UpdateStringTable* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_UpdateStringTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_UpdateStringTable>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_UpdateStringTable& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_UpdateStringTable& from) {
    CSVCMsg_UpdateStringTable::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_UpdateStringTable* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_UpdateStringTable";
  }
  protected:
  explicit CSVCMsg_UpdateStringTable(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kStringDataFieldNumber = 3,
    kTableIdFieldNumber = 1,
    kNumChangedEntriesFieldNumber = 2,
  };
  // optional bytes string_data = 3;
  bool has_string_data() const;
  private:
  bool _internal_has_string_data() const;
  public:
  void clear_string_data();
  const std::string& string_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_string_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_string_data();
  PROTOBUF_NODISCARD std::string* release_string_data();
  void set_allocated_string_data(std::string* string_data);
  private:
  const std::string& _internal_string_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_data(const std::string& value);
  std::string* _internal_mutable_string_data();
  public:

  // optional int32 table_id = 1;
  bool has_table_id() const;
  private:
  bool _internal_has_table_id() const;
  public:
  void clear_table_id();
  int32_t table_id() const;
  void set_table_id(int32_t value);
  private:
  int32_t _internal_table_id() const;
  void _internal_set_table_id(int32_t value);
  public:

  // optional int32 num_changed_entries = 2;
  bool has_num_changed_entries() const;
  private:
  bool _internal_has_num_changed_entries() const;
  public:
  void clear_num_changed_entries();
  int32_t num_changed_entries() const;
  void set_num_changed_entries(int32_t value);
  private:
  int32_t _internal_num_changed_entries() const;
  void _internal_set_num_changed_entries(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_UpdateStringTable)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_data_;
    int32_t table_id_;
    int32_t num_changed_entries_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_VoiceData final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_VoiceData) */ {
 public:
  inline CSVCMsg_VoiceData() : CSVCMsg_VoiceData(nullptr) {}
  ~CSVCMsg_VoiceData() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_VoiceData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_VoiceData(const CSVCMsg_VoiceData& from);
  CSVCMsg_VoiceData(CSVCMsg_VoiceData&& from) noexcept
    : CSVCMsg_VoiceData() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_VoiceData& operator=(const CSVCMsg_VoiceData& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_VoiceData& operator=(CSVCMsg_VoiceData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_VoiceData& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_VoiceData* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_VoiceData*>(
               &_CSVCMsg_VoiceData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    44;

  friend void swap(CSVCMsg_VoiceData& a, CSVCMsg_VoiceData& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_VoiceData* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_VoiceData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_VoiceData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_VoiceData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_VoiceData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_VoiceData& from) {
    CSVCMsg_VoiceData::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_VoiceData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_VoiceData";
  }
  protected:
  explicit CSVCMsg_VoiceData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAudioFieldNumber = 1,
    kXuidFieldNumber = 4,
    kProximityFieldNumber = 3,
    kAudibleMaskFieldNumber = 5,
    kTickFieldNumber = 6,
    kPassthroughFieldNumber = 7,
    kClientFieldNumber = 2,
  };
  // optional .CMsgVoiceAudio audio = 1;
  bool has_audio() const;
  private:
  bool _internal_has_audio() const;
  public:
  void clear_audio();
  const ::CMsgVoiceAudio& audio() const;
  PROTOBUF_NODISCARD ::CMsgVoiceAudio* release_audio();
  ::CMsgVoiceAudio* mutable_audio();
  void set_allocated_audio(::CMsgVoiceAudio* audio);
  private:
  const ::CMsgVoiceAudio& _internal_audio() const;
  ::CMsgVoiceAudio* _internal_mutable_audio();
  public:
  void unsafe_arena_set_allocated_audio(
      ::CMsgVoiceAudio* audio);
  ::CMsgVoiceAudio* unsafe_arena_release_audio();

  // optional fixed64 xuid = 4;
  bool has_xuid() const;
  private:
  bool _internal_has_xuid() const;
  public:
  void clear_xuid();
  uint64_t xuid() const;
  void set_xuid(uint64_t value);
  private:
  uint64_t _internal_xuid() const;
  void _internal_set_xuid(uint64_t value);
  public:

  // optional bool proximity = 3;
  bool has_proximity() const;
  private:
  bool _internal_has_proximity() const;
  public:
  void clear_proximity();
  bool proximity() const;
  void set_proximity(bool value);
  private:
  bool _internal_proximity() const;
  void _internal_set_proximity(bool value);
  public:

  // optional int32 audible_mask = 5;
  bool has_audible_mask() const;
  private:
  bool _internal_has_audible_mask() const;
  public:
  void clear_audible_mask();
  int32_t audible_mask() const;
  void set_audible_mask(int32_t value);
  private:
  int32_t _internal_audible_mask() const;
  void _internal_set_audible_mask(int32_t value);
  public:

  // optional uint32 tick = 6;
  bool has_tick() const;
  private:
  bool _internal_has_tick() const;
  public:
  void clear_tick();
  uint32_t tick() const;
  void set_tick(uint32_t value);
  private:
  uint32_t _internal_tick() const;
  void _internal_set_tick(uint32_t value);
  public:

  // optional int32 passthrough = 7;
  bool has_passthrough() const;
  private:
  bool _internal_has_passthrough() const;
  public:
  void clear_passthrough();
  int32_t passthrough() const;
  void set_passthrough(int32_t value);
  private:
  int32_t _internal_passthrough() const;
  void _internal_set_passthrough(int32_t value);
  public:

  // optional int32 client = 2 [default = -1];
  bool has_client() const;
  private:
  bool _internal_has_client() const;
  public:
  void clear_client();
  int32_t client() const;
  void set_client(int32_t value);
  private:
  int32_t _internal_client() const;
  void _internal_set_client(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_VoiceData)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::CMsgVoiceAudio* audio_;
    uint64_t xuid_;
    bool proximity_;
    int32_t audible_mask_;
    uint32_t tick_;
    int32_t passthrough_;
    int32_t client_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_PacketReliable final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_PacketReliable) */ {
 public:
  inline CSVCMsg_PacketReliable() : CSVCMsg_PacketReliable(nullptr) {}
  ~CSVCMsg_PacketReliable() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_PacketReliable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_PacketReliable(const CSVCMsg_PacketReliable& from);
  CSVCMsg_PacketReliable(CSVCMsg_PacketReliable&& from) noexcept
    : CSVCMsg_PacketReliable() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_PacketReliable& operator=(const CSVCMsg_PacketReliable& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_PacketReliable& operator=(CSVCMsg_PacketReliable&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_PacketReliable& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_PacketReliable* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_PacketReliable*>(
               &_CSVCMsg_PacketReliable_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    45;

  friend void swap(CSVCMsg_PacketReliable& a, CSVCMsg_PacketReliable& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_PacketReliable* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_PacketReliable* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_PacketReliable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_PacketReliable>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_PacketReliable& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_PacketReliable& from) {
    CSVCMsg_PacketReliable::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_PacketReliable* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_PacketReliable";
  }
  protected:
  explicit CSVCMsg_PacketReliable(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTickFieldNumber = 1,
    kMessagessizeFieldNumber = 2,
    kStateFieldNumber = 3,
  };
  // optional int32 tick = 1;
  bool has_tick() const;
  private:
  bool _internal_has_tick() const;
  public:
  void clear_tick();
  int32_t tick() const;
  void set_tick(int32_t value);
  private:
  int32_t _internal_tick() const;
  void _internal_set_tick(int32_t value);
  public:

  // optional int32 messagessize = 2;
  bool has_messagessize() const;
  private:
  bool _internal_has_messagessize() const;
  public:
  void clear_messagessize();
  int32_t messagessize() const;
  void set_messagessize(int32_t value);
  private:
  int32_t _internal_messagessize() const;
  void _internal_set_messagessize(int32_t value);
  public:

  // optional bool state = 3;
  bool has_state() const;
  private:
  bool _internal_has_state() const;
  public:
  void clear_state();
  bool state() const;
  void set_state(bool value);
  private:
  bool _internal_state() const;
  void _internal_set_state(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_PacketReliable)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t tick_;
    int32_t messagessize_;
    bool state_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_FullFrameSplit final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_FullFrameSplit) */ {
 public:
  inline CSVCMsg_FullFrameSplit() : CSVCMsg_FullFrameSplit(nullptr) {}
  ~CSVCMsg_FullFrameSplit() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_FullFrameSplit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_FullFrameSplit(const CSVCMsg_FullFrameSplit& from);
  CSVCMsg_FullFrameSplit(CSVCMsg_FullFrameSplit&& from) noexcept
    : CSVCMsg_FullFrameSplit() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_FullFrameSplit& operator=(const CSVCMsg_FullFrameSplit& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_FullFrameSplit& operator=(CSVCMsg_FullFrameSplit&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_FullFrameSplit& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_FullFrameSplit* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_FullFrameSplit*>(
               &_CSVCMsg_FullFrameSplit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    46;

  friend void swap(CSVCMsg_FullFrameSplit& a, CSVCMsg_FullFrameSplit& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_FullFrameSplit* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_FullFrameSplit* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_FullFrameSplit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_FullFrameSplit>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_FullFrameSplit& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_FullFrameSplit& from) {
    CSVCMsg_FullFrameSplit::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_FullFrameSplit* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_FullFrameSplit";
  }
  protected:
  explicit CSVCMsg_FullFrameSplit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 4,
    kTickFieldNumber = 1,
    kSectionFieldNumber = 2,
    kTotalFieldNumber = 3,
  };
  // optional bytes data = 4;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // optional int32 tick = 1;
  bool has_tick() const;
  private:
  bool _internal_has_tick() const;
  public:
  void clear_tick();
  int32_t tick() const;
  void set_tick(int32_t value);
  private:
  int32_t _internal_tick() const;
  void _internal_set_tick(int32_t value);
  public:

  // optional int32 section = 2;
  bool has_section() const;
  private:
  bool _internal_has_section() const;
  public:
  void clear_section();
  int32_t section() const;
  void set_section(int32_t value);
  private:
  int32_t _internal_section() const;
  void _internal_set_section(int32_t value);
  public:

  // optional int32 total = 3;
  bool has_total() const;
  private:
  bool _internal_has_total() const;
  public:
  void clear_total();
  int32_t total() const;
  void set_total(int32_t value);
  private:
  int32_t _internal_total() const;
  void _internal_set_total(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_FullFrameSplit)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    int32_t tick_;
    int32_t section_;
    int32_t total_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_HLTVStatus final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_HLTVStatus) */ {
 public:
  inline CSVCMsg_HLTVStatus() : CSVCMsg_HLTVStatus(nullptr) {}
  ~CSVCMsg_HLTVStatus() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_HLTVStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_HLTVStatus(const CSVCMsg_HLTVStatus& from);
  CSVCMsg_HLTVStatus(CSVCMsg_HLTVStatus&& from) noexcept
    : CSVCMsg_HLTVStatus() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_HLTVStatus& operator=(const CSVCMsg_HLTVStatus& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_HLTVStatus& operator=(CSVCMsg_HLTVStatus&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_HLTVStatus& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_HLTVStatus* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_HLTVStatus*>(
               &_CSVCMsg_HLTVStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    47;

  friend void swap(CSVCMsg_HLTVStatus& a, CSVCMsg_HLTVStatus& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_HLTVStatus* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_HLTVStatus* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_HLTVStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_HLTVStatus>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_HLTVStatus& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_HLTVStatus& from) {
    CSVCMsg_HLTVStatus::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_HLTVStatus* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_HLTVStatus";
  }
  protected:
  explicit CSVCMsg_HLTVStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMasterFieldNumber = 1,
    kClientsFieldNumber = 2,
    kSlotsFieldNumber = 3,
    kProxiesFieldNumber = 4,
  };
  // optional string master = 1;
  bool has_master() const;
  private:
  bool _internal_has_master() const;
  public:
  void clear_master();
  const std::string& master() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_master(ArgT0&& arg0, ArgT... args);
  std::string* mutable_master();
  PROTOBUF_NODISCARD std::string* release_master();
  void set_allocated_master(std::string* master);
  private:
  const std::string& _internal_master() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_master(const std::string& value);
  std::string* _internal_mutable_master();
  public:

  // optional int32 clients = 2;
  bool has_clients() const;
  private:
  bool _internal_has_clients() const;
  public:
  void clear_clients();
  int32_t clients() const;
  void set_clients(int32_t value);
  private:
  int32_t _internal_clients() const;
  void _internal_set_clients(int32_t value);
  public:

  // optional int32 slots = 3;
  bool has_slots() const;
  private:
  bool _internal_has_slots() const;
  public:
  void clear_slots();
  int32_t slots() const;
  void set_slots(int32_t value);
  private:
  int32_t _internal_slots() const;
  void _internal_set_slots(int32_t value);
  public:

  // optional int32 proxies = 4;
  bool has_proxies() const;
  private:
  bool _internal_has_proxies() const;
  public:
  void clear_proxies();
  int32_t proxies() const;
  void set_proxies(int32_t value);
  private:
  int32_t _internal_proxies() const;
  void _internal_set_proxies(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_HLTVStatus)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr master_;
    int32_t clients_;
    int32_t slots_;
    int32_t proxies_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_ServerSteamID final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_ServerSteamID) */ {
 public:
  inline CSVCMsg_ServerSteamID() : CSVCMsg_ServerSteamID(nullptr) {}
  ~CSVCMsg_ServerSteamID() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_ServerSteamID(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_ServerSteamID(const CSVCMsg_ServerSteamID& from);
  CSVCMsg_ServerSteamID(CSVCMsg_ServerSteamID&& from) noexcept
    : CSVCMsg_ServerSteamID() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_ServerSteamID& operator=(const CSVCMsg_ServerSteamID& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_ServerSteamID& operator=(CSVCMsg_ServerSteamID&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_ServerSteamID& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_ServerSteamID* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_ServerSteamID*>(
               &_CSVCMsg_ServerSteamID_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    48;

  friend void swap(CSVCMsg_ServerSteamID& a, CSVCMsg_ServerSteamID& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_ServerSteamID* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_ServerSteamID* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_ServerSteamID* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_ServerSteamID>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_ServerSteamID& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_ServerSteamID& from) {
    CSVCMsg_ServerSteamID::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_ServerSteamID* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_ServerSteamID";
  }
  protected:
  explicit CSVCMsg_ServerSteamID(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSteamIdFieldNumber = 1,
  };
  // optional uint64 steam_id = 1;
  bool has_steam_id() const;
  private:
  bool _internal_has_steam_id() const;
  public:
  void clear_steam_id();
  uint64_t steam_id() const;
  void set_steam_id(uint64_t value);
  private:
  uint64_t _internal_steam_id() const;
  void _internal_set_steam_id(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_ServerSteamID)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t steam_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_CmdKeyValues final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_CmdKeyValues) */ {
 public:
  inline CSVCMsg_CmdKeyValues() : CSVCMsg_CmdKeyValues(nullptr) {}
  ~CSVCMsg_CmdKeyValues() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_CmdKeyValues(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_CmdKeyValues(const CSVCMsg_CmdKeyValues& from);
  CSVCMsg_CmdKeyValues(CSVCMsg_CmdKeyValues&& from) noexcept
    : CSVCMsg_CmdKeyValues() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_CmdKeyValues& operator=(const CSVCMsg_CmdKeyValues& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_CmdKeyValues& operator=(CSVCMsg_CmdKeyValues&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_CmdKeyValues& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_CmdKeyValues* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_CmdKeyValues*>(
               &_CSVCMsg_CmdKeyValues_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    49;

  friend void swap(CSVCMsg_CmdKeyValues& a, CSVCMsg_CmdKeyValues& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_CmdKeyValues* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_CmdKeyValues* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_CmdKeyValues* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_CmdKeyValues>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_CmdKeyValues& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_CmdKeyValues& from) {
    CSVCMsg_CmdKeyValues::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_CmdKeyValues* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_CmdKeyValues";
  }
  protected:
  explicit CSVCMsg_CmdKeyValues(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
  };
  // optional bytes data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_CmdKeyValues)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_RconServerDetails final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_RconServerDetails) */ {
 public:
  inline CSVCMsg_RconServerDetails() : CSVCMsg_RconServerDetails(nullptr) {}
  ~CSVCMsg_RconServerDetails() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_RconServerDetails(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_RconServerDetails(const CSVCMsg_RconServerDetails& from);
  CSVCMsg_RconServerDetails(CSVCMsg_RconServerDetails&& from) noexcept
    : CSVCMsg_RconServerDetails() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_RconServerDetails& operator=(const CSVCMsg_RconServerDetails& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_RconServerDetails& operator=(CSVCMsg_RconServerDetails&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_RconServerDetails& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_RconServerDetails* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_RconServerDetails*>(
               &_CSVCMsg_RconServerDetails_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    50;

  friend void swap(CSVCMsg_RconServerDetails& a, CSVCMsg_RconServerDetails& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_RconServerDetails* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_RconServerDetails* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_RconServerDetails* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_RconServerDetails>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_RconServerDetails& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_RconServerDetails& from) {
    CSVCMsg_RconServerDetails::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_RconServerDetails* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_RconServerDetails";
  }
  protected:
  explicit CSVCMsg_RconServerDetails(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTokenFieldNumber = 1,
    kDetailsFieldNumber = 2,
  };
  // optional bytes token = 1;
  bool has_token() const;
  private:
  bool _internal_has_token() const;
  public:
  void clear_token();
  const std::string& token() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_token(ArgT0&& arg0, ArgT... args);
  std::string* mutable_token();
  PROTOBUF_NODISCARD std::string* release_token();
  void set_allocated_token(std::string* token);
  private:
  const std::string& _internal_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
  std::string* _internal_mutable_token();
  public:

  // optional string details = 2;
  bool has_details() const;
  private:
  bool _internal_has_details() const;
  public:
  void clear_details();
  const std::string& details() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_details(ArgT0&& arg0, ArgT... args);
  std::string* mutable_details();
  PROTOBUF_NODISCARD std::string* release_details();
  void set_allocated_details(std::string* details);
  private:
  const std::string& _internal_details() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value);
  std::string* _internal_mutable_details();
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_RconServerDetails)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr details_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgIPCAddress final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgIPCAddress) */ {
 public:
  inline CMsgIPCAddress() : CMsgIPCAddress(nullptr) {}
  ~CMsgIPCAddress() override;
  explicit PROTOBUF_CONSTEXPR CMsgIPCAddress(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgIPCAddress(const CMsgIPCAddress& from);
  CMsgIPCAddress(CMsgIPCAddress&& from) noexcept
    : CMsgIPCAddress() {
    *this = ::std::move(from);
  }

  inline CMsgIPCAddress& operator=(const CMsgIPCAddress& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgIPCAddress& operator=(CMsgIPCAddress&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgIPCAddress& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgIPCAddress* internal_default_instance() {
    return reinterpret_cast<const CMsgIPCAddress*>(
               &_CMsgIPCAddress_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    51;

  friend void swap(CMsgIPCAddress& a, CMsgIPCAddress& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgIPCAddress* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgIPCAddress* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgIPCAddress* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgIPCAddress>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgIPCAddress& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgIPCAddress& from) {
    CMsgIPCAddress::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgIPCAddress* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgIPCAddress";
  }
  protected:
  explicit CMsgIPCAddress(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kComputerGuidFieldNumber = 1,
    kProcessIdFieldNumber = 2,
  };
  // optional fixed64 computer_guid = 1;
  bool has_computer_guid() const;
  private:
  bool _internal_has_computer_guid() const;
  public:
  void clear_computer_guid();
  uint64_t computer_guid() const;
  void set_computer_guid(uint64_t value);
  private:
  uint64_t _internal_computer_guid() const;
  void _internal_set_computer_guid(uint64_t value);
  public:

  // optional uint32 process_id = 2;
  bool has_process_id() const;
  private:
  bool _internal_has_process_id() const;
  public:
  void clear_process_id();
  uint32_t process_id() const;
  void set_process_id(uint32_t value);
  private:
  uint32_t _internal_process_id() const;
  void _internal_set_process_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgIPCAddress)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t computer_guid_;
    uint32_t process_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgServerPeer final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgServerPeer) */ {
 public:
  inline CMsgServerPeer() : CMsgServerPeer(nullptr) {}
  ~CMsgServerPeer() override;
  explicit PROTOBUF_CONSTEXPR CMsgServerPeer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgServerPeer(const CMsgServerPeer& from);
  CMsgServerPeer(CMsgServerPeer&& from) noexcept
    : CMsgServerPeer() {
    *this = ::std::move(from);
  }

  inline CMsgServerPeer& operator=(const CMsgServerPeer& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgServerPeer& operator=(CMsgServerPeer&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgServerPeer& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgServerPeer* internal_default_instance() {
    return reinterpret_cast<const CMsgServerPeer*>(
               &_CMsgServerPeer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    52;

  friend void swap(CMsgServerPeer& a, CMsgServerPeer& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgServerPeer* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgServerPeer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgServerPeer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgServerPeer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgServerPeer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgServerPeer& from) {
    CMsgServerPeer::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgServerPeer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgServerPeer";
  }
  protected:
  explicit CMsgServerPeer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIpcFieldNumber = 3,
    kSteamidFieldNumber = 2,
    kTheyHearYouFieldNumber = 4,
    kYouHearThemFieldNumber = 5,
    kIsListenserverHostFieldNumber = 6,
    kPlayerSlotFieldNumber = 1,
  };
  // optional .CMsgIPCAddress ipc = 3;
  bool has_ipc() const;
  private:
  bool _internal_has_ipc() const;
  public:
  void clear_ipc();
  const ::CMsgIPCAddress& ipc() const;
  PROTOBUF_NODISCARD ::CMsgIPCAddress* release_ipc();
  ::CMsgIPCAddress* mutable_ipc();
  void set_allocated_ipc(::CMsgIPCAddress* ipc);
  private:
  const ::CMsgIPCAddress& _internal_ipc() const;
  ::CMsgIPCAddress* _internal_mutable_ipc();
  public:
  void unsafe_arena_set_allocated_ipc(
      ::CMsgIPCAddress* ipc);
  ::CMsgIPCAddress* unsafe_arena_release_ipc();

  // optional fixed64 steamid = 2;
  bool has_steamid() const;
  private:
  bool _internal_has_steamid() const;
  public:
  void clear_steamid();
  uint64_t steamid() const;
  void set_steamid(uint64_t value);
  private:
  uint64_t _internal_steamid() const;
  void _internal_set_steamid(uint64_t value);
  public:

  // optional bool they_hear_you = 4;
  bool has_they_hear_you() const;
  private:
  bool _internal_has_they_hear_you() const;
  public:
  void clear_they_hear_you();
  bool they_hear_you() const;
  void set_they_hear_you(bool value);
  private:
  bool _internal_they_hear_you() const;
  void _internal_set_they_hear_you(bool value);
  public:

  // optional bool you_hear_them = 5;
  bool has_you_hear_them() const;
  private:
  bool _internal_has_you_hear_them() const;
  public:
  void clear_you_hear_them();
  bool you_hear_them() const;
  void set_you_hear_them(bool value);
  private:
  bool _internal_you_hear_them() const;
  void _internal_set_you_hear_them(bool value);
  public:

  // optional bool is_listenserver_host = 6;
  bool has_is_listenserver_host() const;
  private:
  bool _internal_has_is_listenserver_host() const;
  public:
  void clear_is_listenserver_host();
  bool is_listenserver_host() const;
  void set_is_listenserver_host(bool value);
  private:
  bool _internal_is_listenserver_host() const;
  void _internal_set_is_listenserver_host(bool value);
  public:

  // optional int32 player_slot = 1 [default = -1];
  bool has_player_slot() const;
  private:
  bool _internal_has_player_slot() const;
  public:
  void clear_player_slot();
  int32_t player_slot() const;
  void set_player_slot(int32_t value);
  private:
  int32_t _internal_player_slot() const;
  void _internal_set_player_slot(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgServerPeer)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::CMsgIPCAddress* ipc_;
    uint64_t steamid_;
    bool they_hear_you_;
    bool you_hear_them_;
    bool is_listenserver_host_;
    int32_t player_slot_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_PeerList final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_PeerList) */ {
 public:
  inline CSVCMsg_PeerList() : CSVCMsg_PeerList(nullptr) {}
  ~CSVCMsg_PeerList() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_PeerList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_PeerList(const CSVCMsg_PeerList& from);
  CSVCMsg_PeerList(CSVCMsg_PeerList&& from) noexcept
    : CSVCMsg_PeerList() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_PeerList& operator=(const CSVCMsg_PeerList& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_PeerList& operator=(CSVCMsg_PeerList&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_PeerList& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_PeerList* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_PeerList*>(
               &_CSVCMsg_PeerList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    53;

  friend void swap(CSVCMsg_PeerList& a, CSVCMsg_PeerList& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_PeerList* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_PeerList* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_PeerList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_PeerList>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_PeerList& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_PeerList& from) {
    CSVCMsg_PeerList::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_PeerList* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_PeerList";
  }
  protected:
  explicit CSVCMsg_PeerList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPeerFieldNumber = 1,
  };
  // repeated .CMsgServerPeer peer = 1;
  int peer_size() const;
  private:
  int _internal_peer_size() const;
  public:
  void clear_peer();
  ::CMsgServerPeer* mutable_peer(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerPeer >*
      mutable_peer();
  private:
  const ::CMsgServerPeer& _internal_peer(int index) const;
  ::CMsgServerPeer* _internal_add_peer();
  public:
  const ::CMsgServerPeer& peer(int index) const;
  ::CMsgServerPeer* add_peer();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerPeer >&
      peer() const;

  // @@protoc_insertion_point(class_scope:CSVCMsg_PeerList)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerPeer > peer_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_ClearAllStringTables final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_ClearAllStringTables) */ {
 public:
  inline CSVCMsg_ClearAllStringTables() : CSVCMsg_ClearAllStringTables(nullptr) {}
  ~CSVCMsg_ClearAllStringTables() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_ClearAllStringTables(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_ClearAllStringTables(const CSVCMsg_ClearAllStringTables& from);
  CSVCMsg_ClearAllStringTables(CSVCMsg_ClearAllStringTables&& from) noexcept
    : CSVCMsg_ClearAllStringTables() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_ClearAllStringTables& operator=(const CSVCMsg_ClearAllStringTables& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_ClearAllStringTables& operator=(CSVCMsg_ClearAllStringTables&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_ClearAllStringTables& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_ClearAllStringTables* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_ClearAllStringTables*>(
               &_CSVCMsg_ClearAllStringTables_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    54;

  friend void swap(CSVCMsg_ClearAllStringTables& a, CSVCMsg_ClearAllStringTables& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_ClearAllStringTables* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_ClearAllStringTables* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_ClearAllStringTables* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_ClearAllStringTables>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_ClearAllStringTables& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_ClearAllStringTables& from) {
    CSVCMsg_ClearAllStringTables::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_ClearAllStringTables* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_ClearAllStringTables";
  }
  protected:
  explicit CSVCMsg_ClearAllStringTables(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMapnameFieldNumber = 1,
    kCreateTablesSkippedFieldNumber = 3,
  };
  // optional string mapname = 1;
  bool has_mapname() const;
  private:
  bool _internal_has_mapname() const;
  public:
  void clear_mapname();
  const std::string& mapname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mapname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mapname();
  PROTOBUF_NODISCARD std::string* release_mapname();
  void set_allocated_mapname(std::string* mapname);
  private:
  const std::string& _internal_mapname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mapname(const std::string& value);
  std::string* _internal_mutable_mapname();
  public:

  // optional bool create_tables_skipped = 3;
  bool has_create_tables_skipped() const;
  private:
  bool _internal_has_create_tables_skipped() const;
  public:
  void clear_create_tables_skipped();
  bool create_tables_skipped() const;
  void set_create_tables_skipped(bool value);
  private:
  bool _internal_create_tables_skipped() const;
  void _internal_set_create_tables_skipped(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_ClearAllStringTables)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mapname_;
    bool create_tables_skipped_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class ProtoFlattenedSerializerField_t_polymorphic_field_t final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ProtoFlattenedSerializerField_t.polymorphic_field_t) */ {
 public:
  inline ProtoFlattenedSerializerField_t_polymorphic_field_t() : ProtoFlattenedSerializerField_t_polymorphic_field_t(nullptr) {}
  ~ProtoFlattenedSerializerField_t_polymorphic_field_t() override;
  explicit PROTOBUF_CONSTEXPR ProtoFlattenedSerializerField_t_polymorphic_field_t(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ProtoFlattenedSerializerField_t_polymorphic_field_t(const ProtoFlattenedSerializerField_t_polymorphic_field_t& from);
  ProtoFlattenedSerializerField_t_polymorphic_field_t(ProtoFlattenedSerializerField_t_polymorphic_field_t&& from) noexcept
    : ProtoFlattenedSerializerField_t_polymorphic_field_t() {
    *this = ::std::move(from);
  }

  inline ProtoFlattenedSerializerField_t_polymorphic_field_t& operator=(const ProtoFlattenedSerializerField_t_polymorphic_field_t& from) {
    CopyFrom(from);
    return *this;
  }
  inline ProtoFlattenedSerializerField_t_polymorphic_field_t& operator=(ProtoFlattenedSerializerField_t_polymorphic_field_t&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ProtoFlattenedSerializerField_t_polymorphic_field_t& default_instance() {
    return *internal_default_instance();
  }
  static inline const ProtoFlattenedSerializerField_t_polymorphic_field_t* internal_default_instance() {
    return reinterpret_cast<const ProtoFlattenedSerializerField_t_polymorphic_field_t*>(
               &_ProtoFlattenedSerializerField_t_polymorphic_field_t_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    55;

  friend void swap(ProtoFlattenedSerializerField_t_polymorphic_field_t& a, ProtoFlattenedSerializerField_t_polymorphic_field_t& b) {
    a.Swap(&b);
  }
  inline void Swap(ProtoFlattenedSerializerField_t_polymorphic_field_t* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ProtoFlattenedSerializerField_t_polymorphic_field_t* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ProtoFlattenedSerializerField_t_polymorphic_field_t* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ProtoFlattenedSerializerField_t_polymorphic_field_t>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ProtoFlattenedSerializerField_t_polymorphic_field_t& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ProtoFlattenedSerializerField_t_polymorphic_field_t& from) {
    ProtoFlattenedSerializerField_t_polymorphic_field_t::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ProtoFlattenedSerializerField_t_polymorphic_field_t* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ProtoFlattenedSerializerField_t.polymorphic_field_t";
  }
  protected:
  explicit ProtoFlattenedSerializerField_t_polymorphic_field_t(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPolymorphicFieldSerializerNameSymFieldNumber = 1,
    kPolymorphicFieldSerializerVersionFieldNumber = 2,
  };
  // optional int32 polymorphic_field_serializer_name_sym = 1;
  bool has_polymorphic_field_serializer_name_sym() const;
  private:
  bool _internal_has_polymorphic_field_serializer_name_sym() const;
  public:
  void clear_polymorphic_field_serializer_name_sym();
  int32_t polymorphic_field_serializer_name_sym() const;
  void set_polymorphic_field_serializer_name_sym(int32_t value);
  private:
  int32_t _internal_polymorphic_field_serializer_name_sym() const;
  void _internal_set_polymorphic_field_serializer_name_sym(int32_t value);
  public:

  // optional int32 polymorphic_field_serializer_version = 2;
  bool has_polymorphic_field_serializer_version() const;
  private:
  bool _internal_has_polymorphic_field_serializer_version() const;
  public:
  void clear_polymorphic_field_serializer_version();
  int32_t polymorphic_field_serializer_version() const;
  void set_polymorphic_field_serializer_version(int32_t value);
  private:
  int32_t _internal_polymorphic_field_serializer_version() const;
  void _internal_set_polymorphic_field_serializer_version(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:ProtoFlattenedSerializerField_t.polymorphic_field_t)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t polymorphic_field_serializer_name_sym_;
    int32_t polymorphic_field_serializer_version_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class ProtoFlattenedSerializerField_t final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ProtoFlattenedSerializerField_t) */ {
 public:
  inline ProtoFlattenedSerializerField_t() : ProtoFlattenedSerializerField_t(nullptr) {}
  ~ProtoFlattenedSerializerField_t() override;
  explicit PROTOBUF_CONSTEXPR ProtoFlattenedSerializerField_t(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ProtoFlattenedSerializerField_t(const ProtoFlattenedSerializerField_t& from);
  ProtoFlattenedSerializerField_t(ProtoFlattenedSerializerField_t&& from) noexcept
    : ProtoFlattenedSerializerField_t() {
    *this = ::std::move(from);
  }

  inline ProtoFlattenedSerializerField_t& operator=(const ProtoFlattenedSerializerField_t& from) {
    CopyFrom(from);
    return *this;
  }
  inline ProtoFlattenedSerializerField_t& operator=(ProtoFlattenedSerializerField_t&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ProtoFlattenedSerializerField_t& default_instance() {
    return *internal_default_instance();
  }
  static inline const ProtoFlattenedSerializerField_t* internal_default_instance() {
    return reinterpret_cast<const ProtoFlattenedSerializerField_t*>(
               &_ProtoFlattenedSerializerField_t_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    56;

  friend void swap(ProtoFlattenedSerializerField_t& a, ProtoFlattenedSerializerField_t& b) {
    a.Swap(&b);
  }
  inline void Swap(ProtoFlattenedSerializerField_t* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ProtoFlattenedSerializerField_t* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ProtoFlattenedSerializerField_t* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ProtoFlattenedSerializerField_t>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ProtoFlattenedSerializerField_t& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ProtoFlattenedSerializerField_t& from) {
    ProtoFlattenedSerializerField_t::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ProtoFlattenedSerializerField_t* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ProtoFlattenedSerializerField_t";
  }
  protected:
  explicit ProtoFlattenedSerializerField_t(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef ProtoFlattenedSerializerField_t_polymorphic_field_t polymorphic_field_t;

  // accessors -------------------------------------------------------

  enum : int {
    kPolymorphicTypesFieldNumber = 11,
    kVarTypeSymFieldNumber = 1,
    kVarNameSymFieldNumber = 2,
    kBitCountFieldNumber = 3,
    kLowValueFieldNumber = 4,
    kHighValueFieldNumber = 5,
    kEncodeFlagsFieldNumber = 6,
    kFieldSerializerNameSymFieldNumber = 7,
    kFieldSerializerVersionFieldNumber = 8,
    kSendNodeSymFieldNumber = 9,
    kVarEncoderSymFieldNumber = 10,
    kVarSerializerSymFieldNumber = 12,
  };
  // repeated .ProtoFlattenedSerializerField_t.polymorphic_field_t polymorphic_types = 11;
  int polymorphic_types_size() const;
  private:
  int _internal_polymorphic_types_size() const;
  public:
  void clear_polymorphic_types();
  ::ProtoFlattenedSerializerField_t_polymorphic_field_t* mutable_polymorphic_types(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ProtoFlattenedSerializerField_t_polymorphic_field_t >*
      mutable_polymorphic_types();
  private:
  const ::ProtoFlattenedSerializerField_t_polymorphic_field_t& _internal_polymorphic_types(int index) const;
  ::ProtoFlattenedSerializerField_t_polymorphic_field_t* _internal_add_polymorphic_types();
  public:
  const ::ProtoFlattenedSerializerField_t_polymorphic_field_t& polymorphic_types(int index) const;
  ::ProtoFlattenedSerializerField_t_polymorphic_field_t* add_polymorphic_types();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ProtoFlattenedSerializerField_t_polymorphic_field_t >&
      polymorphic_types() const;

  // optional int32 var_type_sym = 1;
  bool has_var_type_sym() const;
  private:
  bool _internal_has_var_type_sym() const;
  public:
  void clear_var_type_sym();
  int32_t var_type_sym() const;
  void set_var_type_sym(int32_t value);
  private:
  int32_t _internal_var_type_sym() const;
  void _internal_set_var_type_sym(int32_t value);
  public:

  // optional int32 var_name_sym = 2;
  bool has_var_name_sym() const;
  private:
  bool _internal_has_var_name_sym() const;
  public:
  void clear_var_name_sym();
  int32_t var_name_sym() const;
  void set_var_name_sym(int32_t value);
  private:
  int32_t _internal_var_name_sym() const;
  void _internal_set_var_name_sym(int32_t value);
  public:

  // optional int32 bit_count = 3;
  bool has_bit_count() const;
  private:
  bool _internal_has_bit_count() const;
  public:
  void clear_bit_count();
  int32_t bit_count() const;
  void set_bit_count(int32_t value);
  private:
  int32_t _internal_bit_count() const;
  void _internal_set_bit_count(int32_t value);
  public:

  // optional float low_value = 4;
  bool has_low_value() const;
  private:
  bool _internal_has_low_value() const;
  public:
  void clear_low_value();
  float low_value() const;
  void set_low_value(float value);
  private:
  float _internal_low_value() const;
  void _internal_set_low_value(float value);
  public:

  // optional float high_value = 5;
  bool has_high_value() const;
  private:
  bool _internal_has_high_value() const;
  public:
  void clear_high_value();
  float high_value() const;
  void set_high_value(float value);
  private:
  float _internal_high_value() const;
  void _internal_set_high_value(float value);
  public:

  // optional int32 encode_flags = 6;
  bool has_encode_flags() const;
  private:
  bool _internal_has_encode_flags() const;
  public:
  void clear_encode_flags();
  int32_t encode_flags() const;
  void set_encode_flags(int32_t value);
  private:
  int32_t _internal_encode_flags() const;
  void _internal_set_encode_flags(int32_t value);
  public:

  // optional int32 field_serializer_name_sym = 7;
  bool has_field_serializer_name_sym() const;
  private:
  bool _internal_has_field_serializer_name_sym() const;
  public:
  void clear_field_serializer_name_sym();
  int32_t field_serializer_name_sym() const;
  void set_field_serializer_name_sym(int32_t value);
  private:
  int32_t _internal_field_serializer_name_sym() const;
  void _internal_set_field_serializer_name_sym(int32_t value);
  public:

  // optional int32 field_serializer_version = 8;
  bool has_field_serializer_version() const;
  private:
  bool _internal_has_field_serializer_version() const;
  public:
  void clear_field_serializer_version();
  int32_t field_serializer_version() const;
  void set_field_serializer_version(int32_t value);
  private:
  int32_t _internal_field_serializer_version() const;
  void _internal_set_field_serializer_version(int32_t value);
  public:

  // optional int32 send_node_sym = 9;
  bool has_send_node_sym() const;
  private:
  bool _internal_has_send_node_sym() const;
  public:
  void clear_send_node_sym();
  int32_t send_node_sym() const;
  void set_send_node_sym(int32_t value);
  private:
  int32_t _internal_send_node_sym() const;
  void _internal_set_send_node_sym(int32_t value);
  public:

  // optional int32 var_encoder_sym = 10;
  bool has_var_encoder_sym() const;
  private:
  bool _internal_has_var_encoder_sym() const;
  public:
  void clear_var_encoder_sym();
  int32_t var_encoder_sym() const;
  void set_var_encoder_sym(int32_t value);
  private:
  int32_t _internal_var_encoder_sym() const;
  void _internal_set_var_encoder_sym(int32_t value);
  public:

  // optional int32 var_serializer_sym = 12;
  bool has_var_serializer_sym() const;
  private:
  bool _internal_has_var_serializer_sym() const;
  public:
  void clear_var_serializer_sym();
  int32_t var_serializer_sym() const;
  void set_var_serializer_sym(int32_t value);
  private:
  int32_t _internal_var_serializer_sym() const;
  void _internal_set_var_serializer_sym(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:ProtoFlattenedSerializerField_t)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ProtoFlattenedSerializerField_t_polymorphic_field_t > polymorphic_types_;
    int32_t var_type_sym_;
    int32_t var_name_sym_;
    int32_t bit_count_;
    float low_value_;
    float high_value_;
    int32_t encode_flags_;
    int32_t field_serializer_name_sym_;
    int32_t field_serializer_version_;
    int32_t send_node_sym_;
    int32_t var_encoder_sym_;
    int32_t var_serializer_sym_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class ProtoFlattenedSerializer_t final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ProtoFlattenedSerializer_t) */ {
 public:
  inline ProtoFlattenedSerializer_t() : ProtoFlattenedSerializer_t(nullptr) {}
  ~ProtoFlattenedSerializer_t() override;
  explicit PROTOBUF_CONSTEXPR ProtoFlattenedSerializer_t(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ProtoFlattenedSerializer_t(const ProtoFlattenedSerializer_t& from);
  ProtoFlattenedSerializer_t(ProtoFlattenedSerializer_t&& from) noexcept
    : ProtoFlattenedSerializer_t() {
    *this = ::std::move(from);
  }

  inline ProtoFlattenedSerializer_t& operator=(const ProtoFlattenedSerializer_t& from) {
    CopyFrom(from);
    return *this;
  }
  inline ProtoFlattenedSerializer_t& operator=(ProtoFlattenedSerializer_t&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ProtoFlattenedSerializer_t& default_instance() {
    return *internal_default_instance();
  }
  static inline const ProtoFlattenedSerializer_t* internal_default_instance() {
    return reinterpret_cast<const ProtoFlattenedSerializer_t*>(
               &_ProtoFlattenedSerializer_t_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    57;

  friend void swap(ProtoFlattenedSerializer_t& a, ProtoFlattenedSerializer_t& b) {
    a.Swap(&b);
  }
  inline void Swap(ProtoFlattenedSerializer_t* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ProtoFlattenedSerializer_t* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ProtoFlattenedSerializer_t* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ProtoFlattenedSerializer_t>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ProtoFlattenedSerializer_t& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ProtoFlattenedSerializer_t& from) {
    ProtoFlattenedSerializer_t::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ProtoFlattenedSerializer_t* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "ProtoFlattenedSerializer_t";
  }
  protected:
  explicit ProtoFlattenedSerializer_t(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFieldsIndexFieldNumber = 3,
    kSerializerNameSymFieldNumber = 1,
    kSerializerVersionFieldNumber = 2,
  };
  // repeated int32 fields_index = 3;
  int fields_index_size() const;
  private:
  int _internal_fields_index_size() const;
  public:
  void clear_fields_index();
  private:
  int32_t _internal_fields_index(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_fields_index() const;
  void _internal_add_fields_index(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_fields_index();
  public:
  int32_t fields_index(int index) const;
  void set_fields_index(int index, int32_t value);
  void add_fields_index(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      fields_index() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_fields_index();

  // optional int32 serializer_name_sym = 1;
  bool has_serializer_name_sym() const;
  private:
  bool _internal_has_serializer_name_sym() const;
  public:
  void clear_serializer_name_sym();
  int32_t serializer_name_sym() const;
  void set_serializer_name_sym(int32_t value);
  private:
  int32_t _internal_serializer_name_sym() const;
  void _internal_set_serializer_name_sym(int32_t value);
  public:

  // optional int32 serializer_version = 2;
  bool has_serializer_version() const;
  private:
  bool _internal_has_serializer_version() const;
  public:
  void clear_serializer_version();
  int32_t serializer_version() const;
  void set_serializer_version(int32_t value);
  private:
  int32_t _internal_serializer_version() const;
  void _internal_set_serializer_version(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:ProtoFlattenedSerializer_t)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > fields_index_;
    int32_t serializer_name_sym_;
    int32_t serializer_version_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_FlattenedSerializer final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_FlattenedSerializer) */ {
 public:
  inline CSVCMsg_FlattenedSerializer() : CSVCMsg_FlattenedSerializer(nullptr) {}
  ~CSVCMsg_FlattenedSerializer() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_FlattenedSerializer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_FlattenedSerializer(const CSVCMsg_FlattenedSerializer& from);
  CSVCMsg_FlattenedSerializer(CSVCMsg_FlattenedSerializer&& from) noexcept
    : CSVCMsg_FlattenedSerializer() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_FlattenedSerializer& operator=(const CSVCMsg_FlattenedSerializer& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_FlattenedSerializer& operator=(CSVCMsg_FlattenedSerializer&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_FlattenedSerializer& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_FlattenedSerializer* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_FlattenedSerializer*>(
               &_CSVCMsg_FlattenedSerializer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    58;

  friend void swap(CSVCMsg_FlattenedSerializer& a, CSVCMsg_FlattenedSerializer& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_FlattenedSerializer* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_FlattenedSerializer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_FlattenedSerializer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_FlattenedSerializer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_FlattenedSerializer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_FlattenedSerializer& from) {
    CSVCMsg_FlattenedSerializer::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_FlattenedSerializer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_FlattenedSerializer";
  }
  protected:
  explicit CSVCMsg_FlattenedSerializer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSerializersFieldNumber = 1,
    kSymbolsFieldNumber = 2,
    kFieldsFieldNumber = 3,
  };
  // repeated .ProtoFlattenedSerializer_t serializers = 1;
  int serializers_size() const;
  private:
  int _internal_serializers_size() const;
  public:
  void clear_serializers();
  ::ProtoFlattenedSerializer_t* mutable_serializers(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ProtoFlattenedSerializer_t >*
      mutable_serializers();
  private:
  const ::ProtoFlattenedSerializer_t& _internal_serializers(int index) const;
  ::ProtoFlattenedSerializer_t* _internal_add_serializers();
  public:
  const ::ProtoFlattenedSerializer_t& serializers(int index) const;
  ::ProtoFlattenedSerializer_t* add_serializers();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ProtoFlattenedSerializer_t >&
      serializers() const;

  // repeated string symbols = 2;
  int symbols_size() const;
  private:
  int _internal_symbols_size() const;
  public:
  void clear_symbols();
  const std::string& symbols(int index) const;
  std::string* mutable_symbols(int index);
  void set_symbols(int index, const std::string& value);
  void set_symbols(int index, std::string&& value);
  void set_symbols(int index, const char* value);
  void set_symbols(int index, const char* value, size_t size);
  std::string* add_symbols();
  void add_symbols(const std::string& value);
  void add_symbols(std::string&& value);
  void add_symbols(const char* value);
  void add_symbols(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& symbols() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_symbols();
  private:
  const std::string& _internal_symbols(int index) const;
  std::string* _internal_add_symbols();
  public:

  // repeated .ProtoFlattenedSerializerField_t fields = 3;
  int fields_size() const;
  private:
  int _internal_fields_size() const;
  public:
  void clear_fields();
  ::ProtoFlattenedSerializerField_t* mutable_fields(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ProtoFlattenedSerializerField_t >*
      mutable_fields();
  private:
  const ::ProtoFlattenedSerializerField_t& _internal_fields(int index) const;
  ::ProtoFlattenedSerializerField_t* _internal_add_fields();
  public:
  const ::ProtoFlattenedSerializerField_t& fields(int index) const;
  ::ProtoFlattenedSerializerField_t* add_fields();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ProtoFlattenedSerializerField_t >&
      fields() const;

  // @@protoc_insertion_point(class_scope:CSVCMsg_FlattenedSerializer)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ProtoFlattenedSerializer_t > serializers_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> symbols_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ProtoFlattenedSerializerField_t > fields_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_StopSound final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_StopSound) */ {
 public:
  inline CSVCMsg_StopSound() : CSVCMsg_StopSound(nullptr) {}
  ~CSVCMsg_StopSound() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_StopSound(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_StopSound(const CSVCMsg_StopSound& from);
  CSVCMsg_StopSound(CSVCMsg_StopSound&& from) noexcept
    : CSVCMsg_StopSound() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_StopSound& operator=(const CSVCMsg_StopSound& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_StopSound& operator=(CSVCMsg_StopSound&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_StopSound& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_StopSound* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_StopSound*>(
               &_CSVCMsg_StopSound_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    59;

  friend void swap(CSVCMsg_StopSound& a, CSVCMsg_StopSound& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_StopSound* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_StopSound* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_StopSound* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_StopSound>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_StopSound& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_StopSound& from) {
    CSVCMsg_StopSound::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_StopSound* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_StopSound";
  }
  protected:
  explicit CSVCMsg_StopSound(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kGuidFieldNumber = 1,
  };
  // optional fixed32 guid = 1;
  bool has_guid() const;
  private:
  bool _internal_has_guid() const;
  public:
  void clear_guid();
  uint32_t guid() const;
  void set_guid(uint32_t value);
  private:
  uint32_t _internal_guid() const;
  void _internal_set_guid(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_StopSound)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t guid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CBidirMsg_RebroadcastGameEvent final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CBidirMsg_RebroadcastGameEvent) */ {
 public:
  inline CBidirMsg_RebroadcastGameEvent() : CBidirMsg_RebroadcastGameEvent(nullptr) {}
  ~CBidirMsg_RebroadcastGameEvent() override;
  explicit PROTOBUF_CONSTEXPR CBidirMsg_RebroadcastGameEvent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CBidirMsg_RebroadcastGameEvent(const CBidirMsg_RebroadcastGameEvent& from);
  CBidirMsg_RebroadcastGameEvent(CBidirMsg_RebroadcastGameEvent&& from) noexcept
    : CBidirMsg_RebroadcastGameEvent() {
    *this = ::std::move(from);
  }

  inline CBidirMsg_RebroadcastGameEvent& operator=(const CBidirMsg_RebroadcastGameEvent& from) {
    CopyFrom(from);
    return *this;
  }
  inline CBidirMsg_RebroadcastGameEvent& operator=(CBidirMsg_RebroadcastGameEvent&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CBidirMsg_RebroadcastGameEvent& default_instance() {
    return *internal_default_instance();
  }
  static inline const CBidirMsg_RebroadcastGameEvent* internal_default_instance() {
    return reinterpret_cast<const CBidirMsg_RebroadcastGameEvent*>(
               &_CBidirMsg_RebroadcastGameEvent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    60;

  friend void swap(CBidirMsg_RebroadcastGameEvent& a, CBidirMsg_RebroadcastGameEvent& b) {
    a.Swap(&b);
  }
  inline void Swap(CBidirMsg_RebroadcastGameEvent* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CBidirMsg_RebroadcastGameEvent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CBidirMsg_RebroadcastGameEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CBidirMsg_RebroadcastGameEvent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CBidirMsg_RebroadcastGameEvent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CBidirMsg_RebroadcastGameEvent& from) {
    CBidirMsg_RebroadcastGameEvent::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CBidirMsg_RebroadcastGameEvent* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CBidirMsg_RebroadcastGameEvent";
  }
  protected:
  explicit CBidirMsg_RebroadcastGameEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPosttoserverFieldNumber = 1,
    kBuftypeFieldNumber = 2,
    kReceivingclientsFieldNumber = 4,
    kClientbitcountFieldNumber = 3,
  };
  // optional bool posttoserver = 1;
  bool has_posttoserver() const;
  private:
  bool _internal_has_posttoserver() const;
  public:
  void clear_posttoserver();
  bool posttoserver() const;
  void set_posttoserver(bool value);
  private:
  bool _internal_posttoserver() const;
  void _internal_set_posttoserver(bool value);
  public:

  // optional int32 buftype = 2;
  bool has_buftype() const;
  private:
  bool _internal_has_buftype() const;
  public:
  void clear_buftype();
  int32_t buftype() const;
  void set_buftype(int32_t value);
  private:
  int32_t _internal_buftype() const;
  void _internal_set_buftype(int32_t value);
  public:

  // optional uint64 receivingclients = 4;
  bool has_receivingclients() const;
  private:
  bool _internal_has_receivingclients() const;
  public:
  void clear_receivingclients();
  uint64_t receivingclients() const;
  void set_receivingclients(uint64_t value);
  private:
  uint64_t _internal_receivingclients() const;
  void _internal_set_receivingclients(uint64_t value);
  public:

  // optional uint32 clientbitcount = 3;
  bool has_clientbitcount() const;
  private:
  bool _internal_has_clientbitcount() const;
  public:
  void clear_clientbitcount();
  uint32_t clientbitcount() const;
  void set_clientbitcount(uint32_t value);
  private:
  uint32_t _internal_clientbitcount() const;
  void _internal_set_clientbitcount(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CBidirMsg_RebroadcastGameEvent)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    bool posttoserver_;
    int32_t buftype_;
    uint64_t receivingclients_;
    uint32_t clientbitcount_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CBidirMsg_RebroadcastSource final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CBidirMsg_RebroadcastSource) */ {
 public:
  inline CBidirMsg_RebroadcastSource() : CBidirMsg_RebroadcastSource(nullptr) {}
  ~CBidirMsg_RebroadcastSource() override;
  explicit PROTOBUF_CONSTEXPR CBidirMsg_RebroadcastSource(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CBidirMsg_RebroadcastSource(const CBidirMsg_RebroadcastSource& from);
  CBidirMsg_RebroadcastSource(CBidirMsg_RebroadcastSource&& from) noexcept
    : CBidirMsg_RebroadcastSource() {
    *this = ::std::move(from);
  }

  inline CBidirMsg_RebroadcastSource& operator=(const CBidirMsg_RebroadcastSource& from) {
    CopyFrom(from);
    return *this;
  }
  inline CBidirMsg_RebroadcastSource& operator=(CBidirMsg_RebroadcastSource&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CBidirMsg_RebroadcastSource& default_instance() {
    return *internal_default_instance();
  }
  static inline const CBidirMsg_RebroadcastSource* internal_default_instance() {
    return reinterpret_cast<const CBidirMsg_RebroadcastSource*>(
               &_CBidirMsg_RebroadcastSource_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    61;

  friend void swap(CBidirMsg_RebroadcastSource& a, CBidirMsg_RebroadcastSource& b) {
    a.Swap(&b);
  }
  inline void Swap(CBidirMsg_RebroadcastSource* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CBidirMsg_RebroadcastSource* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CBidirMsg_RebroadcastSource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CBidirMsg_RebroadcastSource>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CBidirMsg_RebroadcastSource& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CBidirMsg_RebroadcastSource& from) {
    CBidirMsg_RebroadcastSource::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CBidirMsg_RebroadcastSource* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CBidirMsg_RebroadcastSource";
  }
  protected:
  explicit CBidirMsg_RebroadcastSource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEventsourceFieldNumber = 1,
  };
  // optional int32 eventsource = 1;
  bool has_eventsource() const;
  private:
  bool _internal_has_eventsource() const;
  public:
  void clear_eventsource();
  int32_t eventsource() const;
  void set_eventsource(int32_t value);
  private:
  int32_t _internal_eventsource() const;
  void _internal_set_eventsource(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CBidirMsg_RebroadcastSource)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t eventsource_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CBidirMsg_PredictionEvent final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CBidirMsg_PredictionEvent) */ {
 public:
  inline CBidirMsg_PredictionEvent() : CBidirMsg_PredictionEvent(nullptr) {}
  ~CBidirMsg_PredictionEvent() override;
  explicit PROTOBUF_CONSTEXPR CBidirMsg_PredictionEvent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CBidirMsg_PredictionEvent(const CBidirMsg_PredictionEvent& from);
  CBidirMsg_PredictionEvent(CBidirMsg_PredictionEvent&& from) noexcept
    : CBidirMsg_PredictionEvent() {
    *this = ::std::move(from);
  }

  inline CBidirMsg_PredictionEvent& operator=(const CBidirMsg_PredictionEvent& from) {
    CopyFrom(from);
    return *this;
  }
  inline CBidirMsg_PredictionEvent& operator=(CBidirMsg_PredictionEvent&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CBidirMsg_PredictionEvent& default_instance() {
    return *internal_default_instance();
  }
  static inline const CBidirMsg_PredictionEvent* internal_default_instance() {
    return reinterpret_cast<const CBidirMsg_PredictionEvent*>(
               &_CBidirMsg_PredictionEvent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    62;

  friend void swap(CBidirMsg_PredictionEvent& a, CBidirMsg_PredictionEvent& b) {
    a.Swap(&b);
  }
  inline void Swap(CBidirMsg_PredictionEvent* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CBidirMsg_PredictionEvent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CBidirMsg_PredictionEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CBidirMsg_PredictionEvent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CBidirMsg_PredictionEvent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CBidirMsg_PredictionEvent& from) {
    CBidirMsg_PredictionEvent::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CBidirMsg_PredictionEvent* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CBidirMsg_PredictionEvent";
  }
  protected:
  explicit CBidirMsg_PredictionEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef CBidirMsg_PredictionEvent_ESyncType ESyncType;
  static constexpr ESyncType ST_Tick =
    CBidirMsg_PredictionEvent_ESyncType_ST_Tick;
  static constexpr ESyncType ST_UserCmdNum =
    CBidirMsg_PredictionEvent_ESyncType_ST_UserCmdNum;
  static inline bool ESyncType_IsValid(int value) {
    return CBidirMsg_PredictionEvent_ESyncType_IsValid(value);
  }
  static constexpr ESyncType ESyncType_MIN =
    CBidirMsg_PredictionEvent_ESyncType_ESyncType_MIN;
  static constexpr ESyncType ESyncType_MAX =
    CBidirMsg_PredictionEvent_ESyncType_ESyncType_MAX;
  static constexpr int ESyncType_ARRAYSIZE =
    CBidirMsg_PredictionEvent_ESyncType_ESyncType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ESyncType_descriptor() {
    return CBidirMsg_PredictionEvent_ESyncType_descriptor();
  }
  template<typename T>
  static inline const std::string& ESyncType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ESyncType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ESyncType_Name.");
    return CBidirMsg_PredictionEvent_ESyncType_Name(enum_t_value);
  }
  static inline bool ESyncType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ESyncType* value) {
    return CBidirMsg_PredictionEvent_ESyncType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kEventDataFieldNumber = 2,
    kEventIdFieldNumber = 1,
    kSyncTypeFieldNumber = 3,
    kSyncValUint32FieldNumber = 4,
  };
  // optional bytes event_data = 2;
  bool has_event_data() const;
  private:
  bool _internal_has_event_data() const;
  public:
  void clear_event_data();
  const std::string& event_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_event_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_event_data();
  PROTOBUF_NODISCARD std::string* release_event_data();
  void set_allocated_event_data(std::string* event_data);
  private:
  const std::string& _internal_event_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_event_data(const std::string& value);
  std::string* _internal_mutable_event_data();
  public:

  // optional uint32 event_id = 1;
  bool has_event_id() const;
  private:
  bool _internal_has_event_id() const;
  public:
  void clear_event_id();
  uint32_t event_id() const;
  void set_event_id(uint32_t value);
  private:
  uint32_t _internal_event_id() const;
  void _internal_set_event_id(uint32_t value);
  public:

  // optional uint32 sync_type = 3;
  bool has_sync_type() const;
  private:
  bool _internal_has_sync_type() const;
  public:
  void clear_sync_type();
  uint32_t sync_type() const;
  void set_sync_type(uint32_t value);
  private:
  uint32_t _internal_sync_type() const;
  void _internal_set_sync_type(uint32_t value);
  public:

  // optional uint32 sync_val_uint32 = 4;
  bool has_sync_val_uint32() const;
  private:
  bool _internal_has_sync_val_uint32() const;
  public:
  void clear_sync_val_uint32();
  uint32_t sync_val_uint32() const;
  void set_sync_val_uint32(uint32_t value);
  private:
  uint32_t _internal_sync_val_uint32() const;
  void _internal_set_sync_val_uint32(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CBidirMsg_PredictionEvent)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr event_data_;
    uint32_t event_id_;
    uint32_t sync_type_;
    uint32_t sync_val_uint32_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgServerNetworkStats_Port final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgServerNetworkStats.Port) */ {
 public:
  inline CMsgServerNetworkStats_Port() : CMsgServerNetworkStats_Port(nullptr) {}
  ~CMsgServerNetworkStats_Port() override;
  explicit PROTOBUF_CONSTEXPR CMsgServerNetworkStats_Port(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgServerNetworkStats_Port(const CMsgServerNetworkStats_Port& from);
  CMsgServerNetworkStats_Port(CMsgServerNetworkStats_Port&& from) noexcept
    : CMsgServerNetworkStats_Port() {
    *this = ::std::move(from);
  }

  inline CMsgServerNetworkStats_Port& operator=(const CMsgServerNetworkStats_Port& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgServerNetworkStats_Port& operator=(CMsgServerNetworkStats_Port&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgServerNetworkStats_Port& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgServerNetworkStats_Port* internal_default_instance() {
    return reinterpret_cast<const CMsgServerNetworkStats_Port*>(
               &_CMsgServerNetworkStats_Port_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    63;

  friend void swap(CMsgServerNetworkStats_Port& a, CMsgServerNetworkStats_Port& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgServerNetworkStats_Port* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgServerNetworkStats_Port* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgServerNetworkStats_Port* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgServerNetworkStats_Port>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgServerNetworkStats_Port& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgServerNetworkStats_Port& from) {
    CMsgServerNetworkStats_Port::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgServerNetworkStats_Port* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgServerNetworkStats.Port";
  }
  protected:
  explicit CMsgServerNetworkStats_Port(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 2,
    kPortFieldNumber = 1,
  };
  // optional string name = 2;
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // optional int32 port = 1;
  bool has_port() const;
  private:
  bool _internal_has_port() const;
  public:
  void clear_port();
  int32_t port() const;
  void set_port(int32_t value);
  private:
  int32_t _internal_port() const;
  void _internal_set_port(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgServerNetworkStats.Port)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    int32_t port_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgServerNetworkStats_Player final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgServerNetworkStats.Player) */ {
 public:
  inline CMsgServerNetworkStats_Player() : CMsgServerNetworkStats_Player(nullptr) {}
  ~CMsgServerNetworkStats_Player() override;
  explicit PROTOBUF_CONSTEXPR CMsgServerNetworkStats_Player(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgServerNetworkStats_Player(const CMsgServerNetworkStats_Player& from);
  CMsgServerNetworkStats_Player(CMsgServerNetworkStats_Player&& from) noexcept
    : CMsgServerNetworkStats_Player() {
    *this = ::std::move(from);
  }

  inline CMsgServerNetworkStats_Player& operator=(const CMsgServerNetworkStats_Player& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgServerNetworkStats_Player& operator=(CMsgServerNetworkStats_Player&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgServerNetworkStats_Player& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgServerNetworkStats_Player* internal_default_instance() {
    return reinterpret_cast<const CMsgServerNetworkStats_Player*>(
               &_CMsgServerNetworkStats_Player_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    64;

  friend void swap(CMsgServerNetworkStats_Player& a, CMsgServerNetworkStats_Player& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgServerNetworkStats_Player* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgServerNetworkStats_Player* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgServerNetworkStats_Player* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgServerNetworkStats_Player>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgServerNetworkStats_Player& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgServerNetworkStats_Player& from) {
    CMsgServerNetworkStats_Player::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgServerNetworkStats_Player* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgServerNetworkStats.Player";
  }
  protected:
  explicit CMsgServerNetworkStats_Player(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRemoteAddrFieldNumber = 2,
    kSteamidFieldNumber = 1,
    kPingAvgMsFieldNumber = 4,
    kPacketLossPctFieldNumber = 5,
    kIsBotFieldNumber = 6,
    kLossInFieldNumber = 7,
    kLossOutFieldNumber = 8,
    kEngineLatencyMsFieldNumber = 9,
  };
  // optional string remote_addr = 2;
  bool has_remote_addr() const;
  private:
  bool _internal_has_remote_addr() const;
  public:
  void clear_remote_addr();
  const std::string& remote_addr() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_remote_addr(ArgT0&& arg0, ArgT... args);
  std::string* mutable_remote_addr();
  PROTOBUF_NODISCARD std::string* release_remote_addr();
  void set_allocated_remote_addr(std::string* remote_addr);
  private:
  const std::string& _internal_remote_addr() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_remote_addr(const std::string& value);
  std::string* _internal_mutable_remote_addr();
  public:

  // optional uint64 steamid = 1;
  bool has_steamid() const;
  private:
  bool _internal_has_steamid() const;
  public:
  void clear_steamid();
  uint64_t steamid() const;
  void set_steamid(uint64_t value);
  private:
  uint64_t _internal_steamid() const;
  void _internal_set_steamid(uint64_t value);
  public:

  // optional int32 ping_avg_ms = 4;
  bool has_ping_avg_ms() const;
  private:
  bool _internal_has_ping_avg_ms() const;
  public:
  void clear_ping_avg_ms();
  int32_t ping_avg_ms() const;
  void set_ping_avg_ms(int32_t value);
  private:
  int32_t _internal_ping_avg_ms() const;
  void _internal_set_ping_avg_ms(int32_t value);
  public:

  // optional float packet_loss_pct = 5;
  bool has_packet_loss_pct() const;
  private:
  bool _internal_has_packet_loss_pct() const;
  public:
  void clear_packet_loss_pct();
  float packet_loss_pct() const;
  void set_packet_loss_pct(float value);
  private:
  float _internal_packet_loss_pct() const;
  void _internal_set_packet_loss_pct(float value);
  public:

  // optional bool is_bot = 6;
  bool has_is_bot() const;
  private:
  bool _internal_has_is_bot() const;
  public:
  void clear_is_bot();
  bool is_bot() const;
  void set_is_bot(bool value);
  private:
  bool _internal_is_bot() const;
  void _internal_set_is_bot(bool value);
  public:

  // optional float loss_in = 7;
  bool has_loss_in() const;
  private:
  bool _internal_has_loss_in() const;
  public:
  void clear_loss_in();
  float loss_in() const;
  void set_loss_in(float value);
  private:
  float _internal_loss_in() const;
  void _internal_set_loss_in(float value);
  public:

  // optional float loss_out = 8;
  bool has_loss_out() const;
  private:
  bool _internal_has_loss_out() const;
  public:
  void clear_loss_out();
  float loss_out() const;
  void set_loss_out(float value);
  private:
  float _internal_loss_out() const;
  void _internal_set_loss_out(float value);
  public:

  // optional int32 engine_latency_ms = 9;
  bool has_engine_latency_ms() const;
  private:
  bool _internal_has_engine_latency_ms() const;
  public:
  void clear_engine_latency_ms();
  int32_t engine_latency_ms() const;
  void set_engine_latency_ms(int32_t value);
  private:
  int32_t _internal_engine_latency_ms() const;
  void _internal_set_engine_latency_ms(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgServerNetworkStats.Player)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remote_addr_;
    uint64_t steamid_;
    int32_t ping_avg_ms_;
    float packet_loss_pct_;
    bool is_bot_;
    float loss_in_;
    float loss_out_;
    int32_t engine_latency_ms_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgServerNetworkStats final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgServerNetworkStats) */ {
 public:
  inline CMsgServerNetworkStats() : CMsgServerNetworkStats(nullptr) {}
  ~CMsgServerNetworkStats() override;
  explicit PROTOBUF_CONSTEXPR CMsgServerNetworkStats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgServerNetworkStats(const CMsgServerNetworkStats& from);
  CMsgServerNetworkStats(CMsgServerNetworkStats&& from) noexcept
    : CMsgServerNetworkStats() {
    *this = ::std::move(from);
  }

  inline CMsgServerNetworkStats& operator=(const CMsgServerNetworkStats& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgServerNetworkStats& operator=(CMsgServerNetworkStats&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgServerNetworkStats& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgServerNetworkStats* internal_default_instance() {
    return reinterpret_cast<const CMsgServerNetworkStats*>(
               &_CMsgServerNetworkStats_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    65;

  friend void swap(CMsgServerNetworkStats& a, CMsgServerNetworkStats& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgServerNetworkStats* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgServerNetworkStats* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgServerNetworkStats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgServerNetworkStats>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgServerNetworkStats& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgServerNetworkStats& from) {
    CMsgServerNetworkStats::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgServerNetworkStats* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgServerNetworkStats";
  }
  protected:
  explicit CMsgServerNetworkStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef CMsgServerNetworkStats_Port Port;
  typedef CMsgServerNetworkStats_Player Player;

  // accessors -------------------------------------------------------

  enum : int {
    kPortsFieldNumber = 17,
    kPlayersFieldNumber = 30,
    kDedicatedFieldNumber = 1,
    kCpuUsageFieldNumber = 2,
    kMemoryUsedMbFieldNumber = 3,
    kMemoryFreeMbFieldNumber = 4,
    kUptimeFieldNumber = 5,
    kSpawnCountFieldNumber = 6,
    kNumClientsFieldNumber = 8,
    kNumBotsFieldNumber = 9,
    kNumSpectatorsFieldNumber = 10,
    kNumTvRelaysFieldNumber = 11,
    kFpsFieldNumber = 12,
    kAvgPingMsFieldNumber = 18,
    kAvgEngineLatencyOutFieldNumber = 19,
    kAvgPacketsOutFieldNumber = 20,
    kAvgPacketsInFieldNumber = 21,
    kAvgLossOutFieldNumber = 22,
    kAvgLossInFieldNumber = 23,
    kAvgDataOutFieldNumber = 24,
    kTotalDataInFieldNumber = 26,
    kTotalPacketsInFieldNumber = 27,
    kTotalDataOutFieldNumber = 28,
    kTotalPacketsOutFieldNumber = 29,
    kAvgDataInFieldNumber = 25,
  };
  // repeated .CMsgServerNetworkStats.Port ports = 17;
  int ports_size() const;
  private:
  int _internal_ports_size() const;
  public:
  void clear_ports();
  ::CMsgServerNetworkStats_Port* mutable_ports(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerNetworkStats_Port >*
      mutable_ports();
  private:
  const ::CMsgServerNetworkStats_Port& _internal_ports(int index) const;
  ::CMsgServerNetworkStats_Port* _internal_add_ports();
  public:
  const ::CMsgServerNetworkStats_Port& ports(int index) const;
  ::CMsgServerNetworkStats_Port* add_ports();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerNetworkStats_Port >&
      ports() const;

  // repeated .CMsgServerNetworkStats.Player players = 30;
  int players_size() const;
  private:
  int _internal_players_size() const;
  public:
  void clear_players();
  ::CMsgServerNetworkStats_Player* mutable_players(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerNetworkStats_Player >*
      mutable_players();
  private:
  const ::CMsgServerNetworkStats_Player& _internal_players(int index) const;
  ::CMsgServerNetworkStats_Player* _internal_add_players();
  public:
  const ::CMsgServerNetworkStats_Player& players(int index) const;
  ::CMsgServerNetworkStats_Player* add_players();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerNetworkStats_Player >&
      players() const;

  // optional bool dedicated = 1;
  bool has_dedicated() const;
  private:
  bool _internal_has_dedicated() const;
  public:
  void clear_dedicated();
  bool dedicated() const;
  void set_dedicated(bool value);
  private:
  bool _internal_dedicated() const;
  void _internal_set_dedicated(bool value);
  public:

  // optional int32 cpu_usage = 2;
  bool has_cpu_usage() const;
  private:
  bool _internal_has_cpu_usage() const;
  public:
  void clear_cpu_usage();
  int32_t cpu_usage() const;
  void set_cpu_usage(int32_t value);
  private:
  int32_t _internal_cpu_usage() const;
  void _internal_set_cpu_usage(int32_t value);
  public:

  // optional int32 memory_used_mb = 3;
  bool has_memory_used_mb() const;
  private:
  bool _internal_has_memory_used_mb() const;
  public:
  void clear_memory_used_mb();
  int32_t memory_used_mb() const;
  void set_memory_used_mb(int32_t value);
  private:
  int32_t _internal_memory_used_mb() const;
  void _internal_set_memory_used_mb(int32_t value);
  public:

  // optional int32 memory_free_mb = 4;
  bool has_memory_free_mb() const;
  private:
  bool _internal_has_memory_free_mb() const;
  public:
  void clear_memory_free_mb();
  int32_t memory_free_mb() const;
  void set_memory_free_mb(int32_t value);
  private:
  int32_t _internal_memory_free_mb() const;
  void _internal_set_memory_free_mb(int32_t value);
  public:

  // optional int32 uptime = 5;
  bool has_uptime() const;
  private:
  bool _internal_has_uptime() const;
  public:
  void clear_uptime();
  int32_t uptime() const;
  void set_uptime(int32_t value);
  private:
  int32_t _internal_uptime() const;
  void _internal_set_uptime(int32_t value);
  public:

  // optional int32 spawn_count = 6;
  bool has_spawn_count() const;
  private:
  bool _internal_has_spawn_count() const;
  public:
  void clear_spawn_count();
  int32_t spawn_count() const;
  void set_spawn_count(int32_t value);
  private:
  int32_t _internal_spawn_count() const;
  void _internal_set_spawn_count(int32_t value);
  public:

  // optional int32 num_clients = 8;
  bool has_num_clients() const;
  private:
  bool _internal_has_num_clients() const;
  public:
  void clear_num_clients();
  int32_t num_clients() const;
  void set_num_clients(int32_t value);
  private:
  int32_t _internal_num_clients() const;
  void _internal_set_num_clients(int32_t value);
  public:

  // optional int32 num_bots = 9;
  bool has_num_bots() const;
  private:
  bool _internal_has_num_bots() const;
  public:
  void clear_num_bots();
  int32_t num_bots() const;
  void set_num_bots(int32_t value);
  private:
  int32_t _internal_num_bots() const;
  void _internal_set_num_bots(int32_t value);
  public:

  // optional int32 num_spectators = 10;
  bool has_num_spectators() const;
  private:
  bool _internal_has_num_spectators() const;
  public:
  void clear_num_spectators();
  int32_t num_spectators() const;
  void set_num_spectators(int32_t value);
  private:
  int32_t _internal_num_spectators() const;
  void _internal_set_num_spectators(int32_t value);
  public:

  // optional int32 num_tv_relays = 11;
  bool has_num_tv_relays() const;
  private:
  bool _internal_has_num_tv_relays() const;
  public:
  void clear_num_tv_relays();
  int32_t num_tv_relays() const;
  void set_num_tv_relays(int32_t value);
  private:
  int32_t _internal_num_tv_relays() const;
  void _internal_set_num_tv_relays(int32_t value);
  public:

  // optional float fps = 12;
  bool has_fps() const;
  private:
  bool _internal_has_fps() const;
  public:
  void clear_fps();
  float fps() const;
  void set_fps(float value);
  private:
  float _internal_fps() const;
  void _internal_set_fps(float value);
  public:

  // optional float avg_ping_ms = 18;
  bool has_avg_ping_ms() const;
  private:
  bool _internal_has_avg_ping_ms() const;
  public:
  void clear_avg_ping_ms();
  float avg_ping_ms() const;
  void set_avg_ping_ms(float value);
  private:
  float _internal_avg_ping_ms() const;
  void _internal_set_avg_ping_ms(float value);
  public:

  // optional float avg_engine_latency_out = 19;
  bool has_avg_engine_latency_out() const;
  private:
  bool _internal_has_avg_engine_latency_out() const;
  public:
  void clear_avg_engine_latency_out();
  float avg_engine_latency_out() const;
  void set_avg_engine_latency_out(float value);
  private:
  float _internal_avg_engine_latency_out() const;
  void _internal_set_avg_engine_latency_out(float value);
  public:

  // optional float avg_packets_out = 20;
  bool has_avg_packets_out() const;
  private:
  bool _internal_has_avg_packets_out() const;
  public:
  void clear_avg_packets_out();
  float avg_packets_out() const;
  void set_avg_packets_out(float value);
  private:
  float _internal_avg_packets_out() const;
  void _internal_set_avg_packets_out(float value);
  public:

  // optional float avg_packets_in = 21;
  bool has_avg_packets_in() const;
  private:
  bool _internal_has_avg_packets_in() const;
  public:
  void clear_avg_packets_in();
  float avg_packets_in() const;
  void set_avg_packets_in(float value);
  private:
  float _internal_avg_packets_in() const;
  void _internal_set_avg_packets_in(float value);
  public:

  // optional float avg_loss_out = 22;
  bool has_avg_loss_out() const;
  private:
  bool _internal_has_avg_loss_out() const;
  public:
  void clear_avg_loss_out();
  float avg_loss_out() const;
  void set_avg_loss_out(float value);
  private:
  float _internal_avg_loss_out() const;
  void _internal_set_avg_loss_out(float value);
  public:

  // optional float avg_loss_in = 23;
  bool has_avg_loss_in() const;
  private:
  bool _internal_has_avg_loss_in() const;
  public:
  void clear_avg_loss_in();
  float avg_loss_in() const;
  void set_avg_loss_in(float value);
  private:
  float _internal_avg_loss_in() const;
  void _internal_set_avg_loss_in(float value);
  public:

  // optional float avg_data_out = 24;
  bool has_avg_data_out() const;
  private:
  bool _internal_has_avg_data_out() const;
  public:
  void clear_avg_data_out();
  float avg_data_out() const;
  void set_avg_data_out(float value);
  private:
  float _internal_avg_data_out() const;
  void _internal_set_avg_data_out(float value);
  public:

  // optional uint64 total_data_in = 26;
  bool has_total_data_in() const;
  private:
  bool _internal_has_total_data_in() const;
  public:
  void clear_total_data_in();
  uint64_t total_data_in() const;
  void set_total_data_in(uint64_t value);
  private:
  uint64_t _internal_total_data_in() const;
  void _internal_set_total_data_in(uint64_t value);
  public:

  // optional uint64 total_packets_in = 27;
  bool has_total_packets_in() const;
  private:
  bool _internal_has_total_packets_in() const;
  public:
  void clear_total_packets_in();
  uint64_t total_packets_in() const;
  void set_total_packets_in(uint64_t value);
  private:
  uint64_t _internal_total_packets_in() const;
  void _internal_set_total_packets_in(uint64_t value);
  public:

  // optional uint64 total_data_out = 28;
  bool has_total_data_out() const;
  private:
  bool _internal_has_total_data_out() const;
  public:
  void clear_total_data_out();
  uint64_t total_data_out() const;
  void set_total_data_out(uint64_t value);
  private:
  uint64_t _internal_total_data_out() const;
  void _internal_set_total_data_out(uint64_t value);
  public:

  // optional uint64 total_packets_out = 29;
  bool has_total_packets_out() const;
  private:
  bool _internal_has_total_packets_out() const;
  public:
  void clear_total_packets_out();
  uint64_t total_packets_out() const;
  void set_total_packets_out(uint64_t value);
  private:
  uint64_t _internal_total_packets_out() const;
  void _internal_set_total_packets_out(uint64_t value);
  public:

  // optional float avg_data_in = 25;
  bool has_avg_data_in() const;
  private:
  bool _internal_has_avg_data_in() const;
  public:
  void clear_avg_data_in();
  float avg_data_in() const;
  void set_avg_data_in(float value);
  private:
  float _internal_avg_data_in() const;
  void _internal_set_avg_data_in(float value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgServerNetworkStats)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerNetworkStats_Port > ports_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerNetworkStats_Player > players_;
    bool dedicated_;
    int32_t cpu_usage_;
    int32_t memory_used_mb_;
    int32_t memory_free_mb_;
    int32_t uptime_;
    int32_t spawn_count_;
    int32_t num_clients_;
    int32_t num_bots_;
    int32_t num_spectators_;
    int32_t num_tv_relays_;
    float fps_;
    float avg_ping_ms_;
    float avg_engine_latency_out_;
    float avg_packets_out_;
    float avg_packets_in_;
    float avg_loss_out_;
    float avg_loss_in_;
    float avg_data_out_;
    uint64_t total_data_in_;
    uint64_t total_packets_in_;
    uint64_t total_data_out_;
    uint64_t total_packets_out_;
    float avg_data_in_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_HltvReplay final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_HltvReplay) */ {
 public:
  inline CSVCMsg_HltvReplay() : CSVCMsg_HltvReplay(nullptr) {}
  ~CSVCMsg_HltvReplay() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_HltvReplay(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_HltvReplay(const CSVCMsg_HltvReplay& from);
  CSVCMsg_HltvReplay(CSVCMsg_HltvReplay&& from) noexcept
    : CSVCMsg_HltvReplay() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_HltvReplay& operator=(const CSVCMsg_HltvReplay& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_HltvReplay& operator=(CSVCMsg_HltvReplay&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_HltvReplay& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_HltvReplay* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_HltvReplay*>(
               &_CSVCMsg_HltvReplay_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    66;

  friend void swap(CSVCMsg_HltvReplay& a, CSVCMsg_HltvReplay& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_HltvReplay* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_HltvReplay* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_HltvReplay* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_HltvReplay>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_HltvReplay& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_HltvReplay& from) {
    CSVCMsg_HltvReplay::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_HltvReplay* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_HltvReplay";
  }
  protected:
  explicit CSVCMsg_HltvReplay(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDelayFieldNumber = 1,
    kReplayStopAtFieldNumber = 3,
    kReplayStartAtFieldNumber = 4,
    kReplaySlowdownBeginFieldNumber = 5,
    kReplaySlowdownEndFieldNumber = 6,
    kReplaySlowdownRateFieldNumber = 7,
    kReasonFieldNumber = 8,
    kPrimaryTargetFieldNumber = 2,
  };
  // optional int32 delay = 1;
  bool has_delay() const;
  private:
  bool _internal_has_delay() const;
  public:
  void clear_delay();
  int32_t delay() const;
  void set_delay(int32_t value);
  private:
  int32_t _internal_delay() const;
  void _internal_set_delay(int32_t value);
  public:

  // optional int32 replay_stop_at = 3;
  bool has_replay_stop_at() const;
  private:
  bool _internal_has_replay_stop_at() const;
  public:
  void clear_replay_stop_at();
  int32_t replay_stop_at() const;
  void set_replay_stop_at(int32_t value);
  private:
  int32_t _internal_replay_stop_at() const;
  void _internal_set_replay_stop_at(int32_t value);
  public:

  // optional int32 replay_start_at = 4;
  bool has_replay_start_at() const;
  private:
  bool _internal_has_replay_start_at() const;
  public:
  void clear_replay_start_at();
  int32_t replay_start_at() const;
  void set_replay_start_at(int32_t value);
  private:
  int32_t _internal_replay_start_at() const;
  void _internal_set_replay_start_at(int32_t value);
  public:

  // optional int32 replay_slowdown_begin = 5;
  bool has_replay_slowdown_begin() const;
  private:
  bool _internal_has_replay_slowdown_begin() const;
  public:
  void clear_replay_slowdown_begin();
  int32_t replay_slowdown_begin() const;
  void set_replay_slowdown_begin(int32_t value);
  private:
  int32_t _internal_replay_slowdown_begin() const;
  void _internal_set_replay_slowdown_begin(int32_t value);
  public:

  // optional int32 replay_slowdown_end = 6;
  bool has_replay_slowdown_end() const;
  private:
  bool _internal_has_replay_slowdown_end() const;
  public:
  void clear_replay_slowdown_end();
  int32_t replay_slowdown_end() const;
  void set_replay_slowdown_end(int32_t value);
  private:
  int32_t _internal_replay_slowdown_end() const;
  void _internal_set_replay_slowdown_end(int32_t value);
  public:

  // optional float replay_slowdown_rate = 7;
  bool has_replay_slowdown_rate() const;
  private:
  bool _internal_has_replay_slowdown_rate() const;
  public:
  void clear_replay_slowdown_rate();
  float replay_slowdown_rate() const;
  void set_replay_slowdown_rate(float value);
  private:
  float _internal_replay_slowdown_rate() const;
  void _internal_set_replay_slowdown_rate(float value);
  public:

  // optional int32 reason = 8;
  bool has_reason() const;
  private:
  bool _internal_has_reason() const;
  public:
  void clear_reason();
  int32_t reason() const;
  void set_reason(int32_t value);
  private:
  int32_t _internal_reason() const;
  void _internal_set_reason(int32_t value);
  public:

  // optional int32 primary_target = 2 [default = -1];
  bool has_primary_target() const;
  private:
  bool _internal_has_primary_target() const;
  public:
  void clear_primary_target();
  int32_t primary_target() const;
  void set_primary_target(int32_t value);
  private:
  int32_t _internal_primary_target() const;
  void _internal_set_primary_target(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_HltvReplay)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t delay_;
    int32_t replay_stop_at_;
    int32_t replay_start_at_;
    int32_t replay_slowdown_begin_;
    int32_t replay_slowdown_end_;
    float replay_slowdown_rate_;
    int32_t reason_;
    int32_t primary_target_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CCLCMsg_HltvReplay final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_HltvReplay) */ {
 public:
  inline CCLCMsg_HltvReplay() : CCLCMsg_HltvReplay(nullptr) {}
  ~CCLCMsg_HltvReplay() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_HltvReplay(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_HltvReplay(const CCLCMsg_HltvReplay& from);
  CCLCMsg_HltvReplay(CCLCMsg_HltvReplay&& from) noexcept
    : CCLCMsg_HltvReplay() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_HltvReplay& operator=(const CCLCMsg_HltvReplay& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_HltvReplay& operator=(CCLCMsg_HltvReplay&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_HltvReplay& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_HltvReplay* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_HltvReplay*>(
               &_CCLCMsg_HltvReplay_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    67;

  friend void swap(CCLCMsg_HltvReplay& a, CCLCMsg_HltvReplay& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_HltvReplay* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_HltvReplay* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_HltvReplay* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_HltvReplay>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_HltvReplay& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_HltvReplay& from) {
    CCLCMsg_HltvReplay::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_HltvReplay* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_HltvReplay";
  }
  protected:
  explicit CCLCMsg_HltvReplay(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRequestFieldNumber = 1,
    kSlowdownLengthFieldNumber = 2,
    kSlowdownRateFieldNumber = 3,
    kEventTimeFieldNumber = 5,
    kPrimaryTargetFieldNumber = 4,
  };
  // optional int32 request = 1;
  bool has_request() const;
  private:
  bool _internal_has_request() const;
  public:
  void clear_request();
  int32_t request() const;
  void set_request(int32_t value);
  private:
  int32_t _internal_request() const;
  void _internal_set_request(int32_t value);
  public:

  // optional float slowdown_length = 2;
  bool has_slowdown_length() const;
  private:
  bool _internal_has_slowdown_length() const;
  public:
  void clear_slowdown_length();
  float slowdown_length() const;
  void set_slowdown_length(float value);
  private:
  float _internal_slowdown_length() const;
  void _internal_set_slowdown_length(float value);
  public:

  // optional float slowdown_rate = 3;
  bool has_slowdown_rate() const;
  private:
  bool _internal_has_slowdown_rate() const;
  public:
  void clear_slowdown_rate();
  float slowdown_rate() const;
  void set_slowdown_rate(float value);
  private:
  float _internal_slowdown_rate() const;
  void _internal_set_slowdown_rate(float value);
  public:

  // optional float event_time = 5;
  bool has_event_time() const;
  private:
  bool _internal_has_event_time() const;
  public:
  void clear_event_time();
  float event_time() const;
  void set_event_time(float value);
  private:
  float _internal_event_time() const;
  void _internal_set_event_time(float value);
  public:

  // optional int32 primary_target = 4 [default = -1];
  bool has_primary_target() const;
  private:
  bool _internal_has_primary_target() const;
  public:
  void clear_primary_target();
  int32_t primary_target() const;
  void set_primary_target(int32_t value);
  private:
  int32_t _internal_primary_target() const;
  void _internal_set_primary_target(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CCLCMsg_HltvReplay)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int32_t request_;
    float slowdown_length_;
    float slowdown_rate_;
    float event_time_;
    int32_t primary_target_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_Broadcast_Command final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_Broadcast_Command) */ {
 public:
  inline CSVCMsg_Broadcast_Command() : CSVCMsg_Broadcast_Command(nullptr) {}
  ~CSVCMsg_Broadcast_Command() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_Broadcast_Command(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_Broadcast_Command(const CSVCMsg_Broadcast_Command& from);
  CSVCMsg_Broadcast_Command(CSVCMsg_Broadcast_Command&& from) noexcept
    : CSVCMsg_Broadcast_Command() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_Broadcast_Command& operator=(const CSVCMsg_Broadcast_Command& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_Broadcast_Command& operator=(CSVCMsg_Broadcast_Command&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_Broadcast_Command& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_Broadcast_Command* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_Broadcast_Command*>(
               &_CSVCMsg_Broadcast_Command_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    68;

  friend void swap(CSVCMsg_Broadcast_Command& a, CSVCMsg_Broadcast_Command& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_Broadcast_Command* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_Broadcast_Command* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_Broadcast_Command* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_Broadcast_Command>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_Broadcast_Command& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_Broadcast_Command& from) {
    CSVCMsg_Broadcast_Command::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_Broadcast_Command* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_Broadcast_Command";
  }
  protected:
  explicit CSVCMsg_Broadcast_Command(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCmdFieldNumber = 1,
  };
  // optional string cmd = 1;
  bool has_cmd() const;
  private:
  bool _internal_has_cmd() const;
  public:
  void clear_cmd();
  const std::string& cmd() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_cmd(ArgT0&& arg0, ArgT... args);
  std::string* mutable_cmd();
  PROTOBUF_NODISCARD std::string* release_cmd();
  void set_allocated_cmd(std::string* cmd);
  private:
  const std::string& _internal_cmd() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_cmd(const std::string& value);
  std::string* _internal_mutable_cmd();
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_Broadcast_Command)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cmd_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CCLCMsg_HltvFixupOperatorTick final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CCLCMsg_HltvFixupOperatorTick) */ {
 public:
  inline CCLCMsg_HltvFixupOperatorTick() : CCLCMsg_HltvFixupOperatorTick(nullptr) {}
  ~CCLCMsg_HltvFixupOperatorTick() override;
  explicit PROTOBUF_CONSTEXPR CCLCMsg_HltvFixupOperatorTick(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CCLCMsg_HltvFixupOperatorTick(const CCLCMsg_HltvFixupOperatorTick& from);
  CCLCMsg_HltvFixupOperatorTick(CCLCMsg_HltvFixupOperatorTick&& from) noexcept
    : CCLCMsg_HltvFixupOperatorTick() {
    *this = ::std::move(from);
  }

  inline CCLCMsg_HltvFixupOperatorTick& operator=(const CCLCMsg_HltvFixupOperatorTick& from) {
    CopyFrom(from);
    return *this;
  }
  inline CCLCMsg_HltvFixupOperatorTick& operator=(CCLCMsg_HltvFixupOperatorTick&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CCLCMsg_HltvFixupOperatorTick& default_instance() {
    return *internal_default_instance();
  }
  static inline const CCLCMsg_HltvFixupOperatorTick* internal_default_instance() {
    return reinterpret_cast<const CCLCMsg_HltvFixupOperatorTick*>(
               &_CCLCMsg_HltvFixupOperatorTick_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    69;

  friend void swap(CCLCMsg_HltvFixupOperatorTick& a, CCLCMsg_HltvFixupOperatorTick& b) {
    a.Swap(&b);
  }
  inline void Swap(CCLCMsg_HltvFixupOperatorTick* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CCLCMsg_HltvFixupOperatorTick* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CCLCMsg_HltvFixupOperatorTick* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CCLCMsg_HltvFixupOperatorTick>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CCLCMsg_HltvFixupOperatorTick& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CCLCMsg_HltvFixupOperatorTick& from) {
    CCLCMsg_HltvFixupOperatorTick::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CCLCMsg_HltvFixupOperatorTick* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CCLCMsg_HltvFixupOperatorTick";
  }
  protected:
  explicit CCLCMsg_HltvFixupOperatorTick(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPropsDataFieldNumber = 2,
    kOriginFieldNumber = 3,
    kEyeAnglesFieldNumber = 4,
    kViewOffsetFieldNumber = 8,
    kTickFieldNumber = 1,
    kObserverModeFieldNumber = 5,
    kCameramanScoreboardFieldNumber = 6,
    kObserverTargetFieldNumber = 7,
  };
  // optional bytes props_data = 2;
  bool has_props_data() const;
  private:
  bool _internal_has_props_data() const;
  public:
  void clear_props_data();
  const std::string& props_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_props_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_props_data();
  PROTOBUF_NODISCARD std::string* release_props_data();
  void set_allocated_props_data(std::string* props_data);
  private:
  const std::string& _internal_props_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_props_data(const std::string& value);
  std::string* _internal_mutable_props_data();
  public:

  // optional .CMsgVector origin = 3;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

  // optional .CMsgQAngle eye_angles = 4;
  bool has_eye_angles() const;
  private:
  bool _internal_has_eye_angles() const;
  public:
  void clear_eye_angles();
  const ::CMsgQAngle& eye_angles() const;
  PROTOBUF_NODISCARD ::CMsgQAngle* release_eye_angles();
  ::CMsgQAngle* mutable_eye_angles();
  void set_allocated_eye_angles(::CMsgQAngle* eye_angles);
  private:
  const ::CMsgQAngle& _internal_eye_angles() const;
  ::CMsgQAngle* _internal_mutable_eye_angles();
  public:
  void unsafe_arena_set_allocated_eye_angles(
      ::CMsgQAngle* eye_angles);
  ::CMsgQAngle* unsafe_arena_release_eye_angles();

  // optional .CMsgVector view_offset = 8;
  bool has_view_offset() const;
  private:
  bool _internal_has_view_offset() const;
  public:
  void clear_view_offset();
  const ::CMsgVector& view_offset() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_view_offset();
  ::CMsgVector* mutable_view_offset();
  void set_allocated_view_offset(::CMsgVector* view_offset);
  private:
  const ::CMsgVector& _internal_view_offset() const;
  ::CMsgVector* _internal_mutable_view_offset();
  public:
  void unsafe_arena_set_allocated_view_offset(
      ::CMsgVector* view_offset);
  ::CMsgVector* unsafe_arena_release_view_offset();

  // optional int32 tick = 1;
  bool has_tick() const;
  private:
  bool _internal_has_tick() const;
  public:
  void clear_tick();
  int32_t tick() const;
  void set_tick(int32_t value);
  private:
  int32_t _internal_tick() const;
  void _internal_set_tick(int32_t value);
  public:

  // optional int32 observer_mode = 5;
  bool has_observer_mode() const;
  private:
  bool _internal_has_observer_mode() const;
  public:
  void clear_observer_mode();
  int32_t observer_mode() const;
  void set_observer_mode(int32_t value);
  private:
  int32_t _internal_observer_mode() const;
  void _internal_set_observer_mode(int32_t value);
  public:

  // optional bool cameraman_scoreboard = 6;
  bool has_cameraman_scoreboard() const;
  private:
  bool _internal_has_cameraman_scoreboard() const;
  public:
  void clear_cameraman_scoreboard();
  bool cameraman_scoreboard() const;
  void set_cameraman_scoreboard(bool value);
  private:
  bool _internal_cameraman_scoreboard() const;
  void _internal_set_cameraman_scoreboard(bool value);
  public:

  // optional int32 observer_target = 7;
  bool has_observer_target() const;
  private:
  bool _internal_has_observer_target() const;
  public:
  void clear_observer_target();
  int32_t observer_target() const;
  void set_observer_target(int32_t value);
  private:
  int32_t _internal_observer_target() const;
  void _internal_set_observer_target(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CCLCMsg_HltvFixupOperatorTick)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr props_data_;
    ::CMsgVector* origin_;
    ::CMsgQAngle* eye_angles_;
    ::CMsgVector* view_offset_;
    int32_t tick_;
    int32_t observer_mode_;
    bool cameraman_scoreboard_;
    int32_t observer_target_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_HltvFixupOperatorStatus final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_HltvFixupOperatorStatus) */ {
 public:
  inline CSVCMsg_HltvFixupOperatorStatus() : CSVCMsg_HltvFixupOperatorStatus(nullptr) {}
  ~CSVCMsg_HltvFixupOperatorStatus() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_HltvFixupOperatorStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_HltvFixupOperatorStatus(const CSVCMsg_HltvFixupOperatorStatus& from);
  CSVCMsg_HltvFixupOperatorStatus(CSVCMsg_HltvFixupOperatorStatus&& from) noexcept
    : CSVCMsg_HltvFixupOperatorStatus() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_HltvFixupOperatorStatus& operator=(const CSVCMsg_HltvFixupOperatorStatus& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_HltvFixupOperatorStatus& operator=(CSVCMsg_HltvFixupOperatorStatus&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_HltvFixupOperatorStatus& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_HltvFixupOperatorStatus* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_HltvFixupOperatorStatus*>(
               &_CSVCMsg_HltvFixupOperatorStatus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    70;

  friend void swap(CSVCMsg_HltvFixupOperatorStatus& a, CSVCMsg_HltvFixupOperatorStatus& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_HltvFixupOperatorStatus* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_HltvFixupOperatorStatus* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_HltvFixupOperatorStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_HltvFixupOperatorStatus>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_HltvFixupOperatorStatus& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_HltvFixupOperatorStatus& from) {
    CSVCMsg_HltvFixupOperatorStatus::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_HltvFixupOperatorStatus* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_HltvFixupOperatorStatus";
  }
  protected:
  explicit CSVCMsg_HltvFixupOperatorStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOverrideOperatorNameFieldNumber = 2,
    kModeFieldNumber = 1,
  };
  // optional string override_operator_name = 2;
  bool has_override_operator_name() const;
  private:
  bool _internal_has_override_operator_name() const;
  public:
  void clear_override_operator_name();
  const std::string& override_operator_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_override_operator_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_override_operator_name();
  PROTOBUF_NODISCARD std::string* release_override_operator_name();
  void set_allocated_override_operator_name(std::string* override_operator_name);
  private:
  const std::string& _internal_override_operator_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_override_operator_name(const std::string& value);
  std::string* _internal_mutable_override_operator_name();
  public:

  // optional uint32 mode = 1;
  bool has_mode() const;
  private:
  bool _internal_has_mode() const;
  public:
  void clear_mode();
  uint32_t mode() const;
  void set_mode(uint32_t value);
  private:
  uint32_t _internal_mode() const;
  void _internal_set_mode(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_HltvFixupOperatorStatus)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr override_operator_name_;
    uint32_t mode_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgServerUserCmd final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgServerUserCmd) */ {
 public:
  inline CMsgServerUserCmd() : CMsgServerUserCmd(nullptr) {}
  ~CMsgServerUserCmd() override;
  explicit PROTOBUF_CONSTEXPR CMsgServerUserCmd(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgServerUserCmd(const CMsgServerUserCmd& from);
  CMsgServerUserCmd(CMsgServerUserCmd&& from) noexcept
    : CMsgServerUserCmd() {
    *this = ::std::move(from);
  }

  inline CMsgServerUserCmd& operator=(const CMsgServerUserCmd& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgServerUserCmd& operator=(CMsgServerUserCmd&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgServerUserCmd& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgServerUserCmd* internal_default_instance() {
    return reinterpret_cast<const CMsgServerUserCmd*>(
               &_CMsgServerUserCmd_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    71;

  friend void swap(CMsgServerUserCmd& a, CMsgServerUserCmd& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgServerUserCmd* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgServerUserCmd* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgServerUserCmd* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgServerUserCmd>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgServerUserCmd& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgServerUserCmd& from) {
    CMsgServerUserCmd::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgServerUserCmd* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgServerUserCmd";
  }
  protected:
  explicit CMsgServerUserCmd(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
    kCmdNumberFieldNumber = 2,
    kServerTickExecutedFieldNumber = 4,
    kClientTickFieldNumber = 5,
    kPlayerSlotFieldNumber = 3,
  };
  // optional bytes data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // optional int32 cmd_number = 2;
  bool has_cmd_number() const;
  private:
  bool _internal_has_cmd_number() const;
  public:
  void clear_cmd_number();
  int32_t cmd_number() const;
  void set_cmd_number(int32_t value);
  private:
  int32_t _internal_cmd_number() const;
  void _internal_set_cmd_number(int32_t value);
  public:

  // optional int32 server_tick_executed = 4;
  bool has_server_tick_executed() const;
  private:
  bool _internal_has_server_tick_executed() const;
  public:
  void clear_server_tick_executed();
  int32_t server_tick_executed() const;
  void set_server_tick_executed(int32_t value);
  private:
  int32_t _internal_server_tick_executed() const;
  void _internal_set_server_tick_executed(int32_t value);
  public:

  // optional int32 client_tick = 5;
  bool has_client_tick() const;
  private:
  bool _internal_has_client_tick() const;
  public:
  void clear_client_tick();
  int32_t client_tick() const;
  void set_client_tick(int32_t value);
  private:
  int32_t _internal_client_tick() const;
  void _internal_set_client_tick(int32_t value);
  public:

  // optional int32 player_slot = 3 [default = -1];
  bool has_player_slot() const;
  private:
  bool _internal_has_player_slot() const;
  public:
  void clear_player_slot();
  int32_t player_slot() const;
  void set_player_slot(int32_t value);
  private:
  int32_t _internal_player_slot() const;
  void _internal_set_player_slot(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgServerUserCmd)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    int32_t cmd_number_;
    int32_t server_tick_executed_;
    int32_t client_tick_;
    int32_t player_slot_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_UserCommands final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_UserCommands) */ {
 public:
  inline CSVCMsg_UserCommands() : CSVCMsg_UserCommands(nullptr) {}
  ~CSVCMsg_UserCommands() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_UserCommands(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_UserCommands(const CSVCMsg_UserCommands& from);
  CSVCMsg_UserCommands(CSVCMsg_UserCommands&& from) noexcept
    : CSVCMsg_UserCommands() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_UserCommands& operator=(const CSVCMsg_UserCommands& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_UserCommands& operator=(CSVCMsg_UserCommands&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_UserCommands& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_UserCommands* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_UserCommands*>(
               &_CSVCMsg_UserCommands_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    72;

  friend void swap(CSVCMsg_UserCommands& a, CSVCMsg_UserCommands& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_UserCommands* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_UserCommands* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_UserCommands* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_UserCommands>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_UserCommands& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_UserCommands& from) {
    CSVCMsg_UserCommands::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_UserCommands* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_UserCommands";
  }
  protected:
  explicit CSVCMsg_UserCommands(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCommandsFieldNumber = 1,
  };
  // repeated .CMsgServerUserCmd commands = 1;
  int commands_size() const;
  private:
  int _internal_commands_size() const;
  public:
  void clear_commands();
  ::CMsgServerUserCmd* mutable_commands(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerUserCmd >*
      mutable_commands();
  private:
  const ::CMsgServerUserCmd& _internal_commands(int index) const;
  ::CMsgServerUserCmd* _internal_add_commands();
  public:
  const ::CMsgServerUserCmd& commands(int index) const;
  ::CMsgServerUserCmd* add_commands();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerUserCmd >&
      commands() const;

  // @@protoc_insertion_point(class_scope:CSVCMsg_UserCommands)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerUserCmd > commands_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// -------------------------------------------------------------------

class CSVCMsg_NextMsgPredicted final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CSVCMsg_NextMsgPredicted) */ {
 public:
  inline CSVCMsg_NextMsgPredicted() : CSVCMsg_NextMsgPredicted(nullptr) {}
  ~CSVCMsg_NextMsgPredicted() override;
  explicit PROTOBUF_CONSTEXPR CSVCMsg_NextMsgPredicted(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CSVCMsg_NextMsgPredicted(const CSVCMsg_NextMsgPredicted& from);
  CSVCMsg_NextMsgPredicted(CSVCMsg_NextMsgPredicted&& from) noexcept
    : CSVCMsg_NextMsgPredicted() {
    *this = ::std::move(from);
  }

  inline CSVCMsg_NextMsgPredicted& operator=(const CSVCMsg_NextMsgPredicted& from) {
    CopyFrom(from);
    return *this;
  }
  inline CSVCMsg_NextMsgPredicted& operator=(CSVCMsg_NextMsgPredicted&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CSVCMsg_NextMsgPredicted& default_instance() {
    return *internal_default_instance();
  }
  static inline const CSVCMsg_NextMsgPredicted* internal_default_instance() {
    return reinterpret_cast<const CSVCMsg_NextMsgPredicted*>(
               &_CSVCMsg_NextMsgPredicted_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    73;

  friend void swap(CSVCMsg_NextMsgPredicted& a, CSVCMsg_NextMsgPredicted& b) {
    a.Swap(&b);
  }
  inline void Swap(CSVCMsg_NextMsgPredicted* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CSVCMsg_NextMsgPredicted* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CSVCMsg_NextMsgPredicted* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CSVCMsg_NextMsgPredicted>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CSVCMsg_NextMsgPredicted& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CSVCMsg_NextMsgPredicted& from) {
    CSVCMsg_NextMsgPredicted::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CSVCMsg_NextMsgPredicted* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSVCMsg_NextMsgPredicted";
  }
  protected:
  explicit CSVCMsg_NextMsgPredicted(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMessageTypeIdFieldNumber = 2,
    kPredictedByPlayerSlotFieldNumber = 1,
  };
  // optional uint32 message_type_id = 2;
  bool has_message_type_id() const;
  private:
  bool _internal_has_message_type_id() const;
  public:
  void clear_message_type_id();
  uint32_t message_type_id() const;
  void set_message_type_id(uint32_t value);
  private:
  uint32_t _internal_message_type_id() const;
  void _internal_set_message_type_id(uint32_t value);
  public:

  // optional int32 predicted_by_player_slot = 1 [default = -1];
  bool has_predicted_by_player_slot() const;
  private:
  bool _internal_has_predicted_by_player_slot() const;
  public:
  void clear_predicted_by_player_slot();
  int32_t predicted_by_player_slot() const;
  void set_predicted_by_player_slot(int32_t value);
  private:
  int32_t _internal_predicted_by_player_slot() const;
  void _internal_set_predicted_by_player_slot(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsg_NextMsgPredicted)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t message_type_id_;
    int32_t predicted_by_player_slot_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_netmessages_2eproto;
};
// ===================================================================


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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// CCLCMsg_ClientInfo

// optional fixed32 send_table_crc = 1;
inline bool CCLCMsg_ClientInfo::_internal_has_send_table_crc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CCLCMsg_ClientInfo::has_send_table_crc() const {
  return _internal_has_send_table_crc();
}
inline void CCLCMsg_ClientInfo::clear_send_table_crc() {
  _impl_.send_table_crc_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CCLCMsg_ClientInfo::_internal_send_table_crc() const {
  return _impl_.send_table_crc_;
}
inline uint32_t CCLCMsg_ClientInfo::send_table_crc() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_ClientInfo.send_table_crc)
  return _internal_send_table_crc();
}
inline void CCLCMsg_ClientInfo::_internal_set_send_table_crc(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.send_table_crc_ = value;
}
inline void CCLCMsg_ClientInfo::set_send_table_crc(uint32_t value) {
  _internal_set_send_table_crc(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_ClientInfo.send_table_crc)
}

// optional uint32 server_count = 2;
inline bool CCLCMsg_ClientInfo::_internal_has_server_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CCLCMsg_ClientInfo::has_server_count() const {
  return _internal_has_server_count();
}
inline void CCLCMsg_ClientInfo::clear_server_count() {
  _impl_.server_count_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CCLCMsg_ClientInfo::_internal_server_count() const {
  return _impl_.server_count_;
}
inline uint32_t CCLCMsg_ClientInfo::server_count() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_ClientInfo.server_count)
  return _internal_server_count();
}
inline void CCLCMsg_ClientInfo::_internal_set_server_count(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.server_count_ = value;
}
inline void CCLCMsg_ClientInfo::set_server_count(uint32_t value) {
  _internal_set_server_count(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_ClientInfo.server_count)
}

// optional bool is_hltv = 3;
inline bool CCLCMsg_ClientInfo::_internal_has_is_hltv() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CCLCMsg_ClientInfo::has_is_hltv() const {
  return _internal_has_is_hltv();
}
inline void CCLCMsg_ClientInfo::clear_is_hltv() {
  _impl_.is_hltv_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool CCLCMsg_ClientInfo::_internal_is_hltv() const {
  return _impl_.is_hltv_;
}
inline bool CCLCMsg_ClientInfo::is_hltv() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_ClientInfo.is_hltv)
  return _internal_is_hltv();
}
inline void CCLCMsg_ClientInfo::_internal_set_is_hltv(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.is_hltv_ = value;
}
inline void CCLCMsg_ClientInfo::set_is_hltv(bool value) {
  _internal_set_is_hltv(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_ClientInfo.is_hltv)
}

// optional uint32 friends_id = 5;
inline bool CCLCMsg_ClientInfo::_internal_has_friends_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CCLCMsg_ClientInfo::has_friends_id() const {
  return _internal_has_friends_id();
}
inline void CCLCMsg_ClientInfo::clear_friends_id() {
  _impl_.friends_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CCLCMsg_ClientInfo::_internal_friends_id() const {
  return _impl_.friends_id_;
}
inline uint32_t CCLCMsg_ClientInfo::friends_id() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_ClientInfo.friends_id)
  return _internal_friends_id();
}
inline void CCLCMsg_ClientInfo::_internal_set_friends_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.friends_id_ = value;
}
inline void CCLCMsg_ClientInfo::set_friends_id(uint32_t value) {
  _internal_set_friends_id(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_ClientInfo.friends_id)
}

// optional string friends_name = 6;
inline bool CCLCMsg_ClientInfo::_internal_has_friends_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CCLCMsg_ClientInfo::has_friends_name() const {
  return _internal_has_friends_name();
}
inline void CCLCMsg_ClientInfo::clear_friends_name() {
  _impl_.friends_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CCLCMsg_ClientInfo::friends_name() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_ClientInfo.friends_name)
  return _internal_friends_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CCLCMsg_ClientInfo::set_friends_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.friends_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CCLCMsg_ClientInfo.friends_name)
}
inline std::string* CCLCMsg_ClientInfo::mutable_friends_name() {
  std::string* _s = _internal_mutable_friends_name();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_ClientInfo.friends_name)
  return _s;
}
inline const std::string& CCLCMsg_ClientInfo::_internal_friends_name() const {
  return _impl_.friends_name_.Get();
}
inline void CCLCMsg_ClientInfo::_internal_set_friends_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.friends_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CCLCMsg_ClientInfo::_internal_mutable_friends_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.friends_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CCLCMsg_ClientInfo::release_friends_name() {
  // @@protoc_insertion_point(field_release:CCLCMsg_ClientInfo.friends_name)
  if (!_internal_has_friends_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.friends_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.friends_name_.IsDefault()) {
    _impl_.friends_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CCLCMsg_ClientInfo::set_allocated_friends_name(std::string* friends_name) {
  if (friends_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.friends_name_.SetAllocated(friends_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.friends_name_.IsDefault()) {
    _impl_.friends_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_ClientInfo.friends_name)
}

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

// CCLCMsg_Move

// optional bytes data = 3;
inline bool CCLCMsg_Move::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CCLCMsg_Move::has_data() const {
  return _internal_has_data();
}
inline void CCLCMsg_Move::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CCLCMsg_Move::data() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_Move.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CCLCMsg_Move::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CCLCMsg_Move.data)
}
inline std::string* CCLCMsg_Move::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_Move.data)
  return _s;
}
inline const std::string& CCLCMsg_Move::_internal_data() const {
  return _impl_.data_.Get();
}
inline void CCLCMsg_Move::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* CCLCMsg_Move::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* CCLCMsg_Move::release_data() {
  // @@protoc_insertion_point(field_release:CCLCMsg_Move.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CCLCMsg_Move::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_Move.data)
}

// optional uint32 last_command_number = 4;
inline bool CCLCMsg_Move::_internal_has_last_command_number() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CCLCMsg_Move::has_last_command_number() const {
  return _internal_has_last_command_number();
}
inline void CCLCMsg_Move::clear_last_command_number() {
  _impl_.last_command_number_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CCLCMsg_Move::_internal_last_command_number() const {
  return _impl_.last_command_number_;
}
inline uint32_t CCLCMsg_Move::last_command_number() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_Move.last_command_number)
  return _internal_last_command_number();
}
inline void CCLCMsg_Move::_internal_set_last_command_number(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.last_command_number_ = value;
}
inline void CCLCMsg_Move::set_last_command_number(uint32_t value) {
  _internal_set_last_command_number(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_Move.last_command_number)
}

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

// CMsgVoiceAudio

// optional .VoiceDataFormat_t format = 1 [default = VOICEDATA_FORMAT_STEAM];
inline bool CMsgVoiceAudio::_internal_has_format() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgVoiceAudio::has_format() const {
  return _internal_has_format();
}
inline void CMsgVoiceAudio::clear_format() {
  _impl_.format_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::VoiceDataFormat_t CMsgVoiceAudio::_internal_format() const {
  return static_cast< ::VoiceDataFormat_t >(_impl_.format_);
}
inline ::VoiceDataFormat_t CMsgVoiceAudio::format() const {
  // @@protoc_insertion_point(field_get:CMsgVoiceAudio.format)
  return _internal_format();
}
inline void CMsgVoiceAudio::_internal_set_format(::VoiceDataFormat_t value) {
  assert(::VoiceDataFormat_t_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.format_ = value;
}
inline void CMsgVoiceAudio::set_format(::VoiceDataFormat_t value) {
  _internal_set_format(value);
  // @@protoc_insertion_point(field_set:CMsgVoiceAudio.format)
}

// optional bytes voice_data = 2;
inline bool CMsgVoiceAudio::_internal_has_voice_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgVoiceAudio::has_voice_data() const {
  return _internal_has_voice_data();
}
inline void CMsgVoiceAudio::clear_voice_data() {
  _impl_.voice_data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgVoiceAudio::voice_data() const {
  // @@protoc_insertion_point(field_get:CMsgVoiceAudio.voice_data)
  return _internal_voice_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgVoiceAudio::set_voice_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.voice_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgVoiceAudio.voice_data)
}
inline std::string* CMsgVoiceAudio::mutable_voice_data() {
  std::string* _s = _internal_mutable_voice_data();
  // @@protoc_insertion_point(field_mutable:CMsgVoiceAudio.voice_data)
  return _s;
}
inline const std::string& CMsgVoiceAudio::_internal_voice_data() const {
  return _impl_.voice_data_.Get();
}
inline void CMsgVoiceAudio::_internal_set_voice_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.voice_data_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgVoiceAudio::_internal_mutable_voice_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.voice_data_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgVoiceAudio::release_voice_data() {
  // @@protoc_insertion_point(field_release:CMsgVoiceAudio.voice_data)
  if (!_internal_has_voice_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.voice_data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.voice_data_.IsDefault()) {
    _impl_.voice_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgVoiceAudio::set_allocated_voice_data(std::string* voice_data) {
  if (voice_data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.voice_data_.SetAllocated(voice_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.voice_data_.IsDefault()) {
    _impl_.voice_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgVoiceAudio.voice_data)
}

// optional int32 sequence_bytes = 3;
inline bool CMsgVoiceAudio::_internal_has_sequence_bytes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgVoiceAudio::has_sequence_bytes() const {
  return _internal_has_sequence_bytes();
}
inline void CMsgVoiceAudio::clear_sequence_bytes() {
  _impl_.sequence_bytes_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CMsgVoiceAudio::_internal_sequence_bytes() const {
  return _impl_.sequence_bytes_;
}
inline int32_t CMsgVoiceAudio::sequence_bytes() const {
  // @@protoc_insertion_point(field_get:CMsgVoiceAudio.sequence_bytes)
  return _internal_sequence_bytes();
}
inline void CMsgVoiceAudio::_internal_set_sequence_bytes(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.sequence_bytes_ = value;
}
inline void CMsgVoiceAudio::set_sequence_bytes(int32_t value) {
  _internal_set_sequence_bytes(value);
  // @@protoc_insertion_point(field_set:CMsgVoiceAudio.sequence_bytes)
}

// optional uint32 section_number = 4;
inline bool CMsgVoiceAudio::_internal_has_section_number() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgVoiceAudio::has_section_number() const {
  return _internal_has_section_number();
}
inline void CMsgVoiceAudio::clear_section_number() {
  _impl_.section_number_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgVoiceAudio::_internal_section_number() const {
  return _impl_.section_number_;
}
inline uint32_t CMsgVoiceAudio::section_number() const {
  // @@protoc_insertion_point(field_get:CMsgVoiceAudio.section_number)
  return _internal_section_number();
}
inline void CMsgVoiceAudio::_internal_set_section_number(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.section_number_ = value;
}
inline void CMsgVoiceAudio::set_section_number(uint32_t value) {
  _internal_set_section_number(value);
  // @@protoc_insertion_point(field_set:CMsgVoiceAudio.section_number)
}

// optional uint32 sample_rate = 5;
inline bool CMsgVoiceAudio::_internal_has_sample_rate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgVoiceAudio::has_sample_rate() const {
  return _internal_has_sample_rate();
}
inline void CMsgVoiceAudio::clear_sample_rate() {
  _impl_.sample_rate_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgVoiceAudio::_internal_sample_rate() const {
  return _impl_.sample_rate_;
}
inline uint32_t CMsgVoiceAudio::sample_rate() const {
  // @@protoc_insertion_point(field_get:CMsgVoiceAudio.sample_rate)
  return _internal_sample_rate();
}
inline void CMsgVoiceAudio::_internal_set_sample_rate(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.sample_rate_ = value;
}
inline void CMsgVoiceAudio::set_sample_rate(uint32_t value) {
  _internal_set_sample_rate(value);
  // @@protoc_insertion_point(field_set:CMsgVoiceAudio.sample_rate)
}

// optional uint32 uncompressed_sample_offset = 6;
inline bool CMsgVoiceAudio::_internal_has_uncompressed_sample_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgVoiceAudio::has_uncompressed_sample_offset() const {
  return _internal_has_uncompressed_sample_offset();
}
inline void CMsgVoiceAudio::clear_uncompressed_sample_offset() {
  _impl_.uncompressed_sample_offset_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgVoiceAudio::_internal_uncompressed_sample_offset() const {
  return _impl_.uncompressed_sample_offset_;
}
inline uint32_t CMsgVoiceAudio::uncompressed_sample_offset() const {
  // @@protoc_insertion_point(field_get:CMsgVoiceAudio.uncompressed_sample_offset)
  return _internal_uncompressed_sample_offset();
}
inline void CMsgVoiceAudio::_internal_set_uncompressed_sample_offset(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.uncompressed_sample_offset_ = value;
}
inline void CMsgVoiceAudio::set_uncompressed_sample_offset(uint32_t value) {
  _internal_set_uncompressed_sample_offset(value);
  // @@protoc_insertion_point(field_set:CMsgVoiceAudio.uncompressed_sample_offset)
}

// optional uint32 num_packets = 7;
inline bool CMsgVoiceAudio::_internal_has_num_packets() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgVoiceAudio::has_num_packets() const {
  return _internal_has_num_packets();
}
inline void CMsgVoiceAudio::clear_num_packets() {
  _impl_.num_packets_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgVoiceAudio::_internal_num_packets() const {
  return _impl_.num_packets_;
}
inline uint32_t CMsgVoiceAudio::num_packets() const {
  // @@protoc_insertion_point(field_get:CMsgVoiceAudio.num_packets)
  return _internal_num_packets();
}
inline void CMsgVoiceAudio::_internal_set_num_packets(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.num_packets_ = value;
}
inline void CMsgVoiceAudio::set_num_packets(uint32_t value) {
  _internal_set_num_packets(value);
  // @@protoc_insertion_point(field_set:CMsgVoiceAudio.num_packets)
}

// repeated uint32 packet_offsets = 8 [packed = true];
inline int CMsgVoiceAudio::_internal_packet_offsets_size() const {
  return _impl_.packet_offsets_.size();
}
inline int CMsgVoiceAudio::packet_offsets_size() const {
  return _internal_packet_offsets_size();
}
inline void CMsgVoiceAudio::clear_packet_offsets() {
  _impl_.packet_offsets_.Clear();
}
inline uint32_t CMsgVoiceAudio::_internal_packet_offsets(int index) const {
  return _impl_.packet_offsets_.Get(index);
}
inline uint32_t CMsgVoiceAudio::packet_offsets(int index) const {
  // @@protoc_insertion_point(field_get:CMsgVoiceAudio.packet_offsets)
  return _internal_packet_offsets(index);
}
inline void CMsgVoiceAudio::set_packet_offsets(int index, uint32_t value) {
  _impl_.packet_offsets_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgVoiceAudio.packet_offsets)
}
inline void CMsgVoiceAudio::_internal_add_packet_offsets(uint32_t value) {
  _impl_.packet_offsets_.Add(value);
}
inline void CMsgVoiceAudio::add_packet_offsets(uint32_t value) {
  _internal_add_packet_offsets(value);
  // @@protoc_insertion_point(field_add:CMsgVoiceAudio.packet_offsets)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgVoiceAudio::_internal_packet_offsets() const {
  return _impl_.packet_offsets_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgVoiceAudio::packet_offsets() const {
  // @@protoc_insertion_point(field_list:CMsgVoiceAudio.packet_offsets)
  return _internal_packet_offsets();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgVoiceAudio::_internal_mutable_packet_offsets() {
  return &_impl_.packet_offsets_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgVoiceAudio::mutable_packet_offsets() {
  // @@protoc_insertion_point(field_mutable_list:CMsgVoiceAudio.packet_offsets)
  return _internal_mutable_packet_offsets();
}

// optional float voice_level = 9;
inline bool CMsgVoiceAudio::_internal_has_voice_level() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgVoiceAudio::has_voice_level() const {
  return _internal_has_voice_level();
}
inline void CMsgVoiceAudio::clear_voice_level() {
  _impl_.voice_level_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline float CMsgVoiceAudio::_internal_voice_level() const {
  return _impl_.voice_level_;
}
inline float CMsgVoiceAudio::voice_level() const {
  // @@protoc_insertion_point(field_get:CMsgVoiceAudio.voice_level)
  return _internal_voice_level();
}
inline void CMsgVoiceAudio::_internal_set_voice_level(float value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.voice_level_ = value;
}
inline void CMsgVoiceAudio::set_voice_level(float value) {
  _internal_set_voice_level(value);
  // @@protoc_insertion_point(field_set:CMsgVoiceAudio.voice_level)
}

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

// CCLCMsg_VoiceData

// optional .CMsgVoiceAudio audio = 1;
inline bool CCLCMsg_VoiceData::_internal_has_audio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.audio_ != nullptr);
  return value;
}
inline bool CCLCMsg_VoiceData::has_audio() const {
  return _internal_has_audio();
}
inline void CCLCMsg_VoiceData::clear_audio() {
  if (_impl_.audio_ != nullptr) _impl_.audio_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsgVoiceAudio& CCLCMsg_VoiceData::_internal_audio() const {
  const ::CMsgVoiceAudio* p = _impl_.audio_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVoiceAudio&>(
      ::_CMsgVoiceAudio_default_instance_);
}
inline const ::CMsgVoiceAudio& CCLCMsg_VoiceData::audio() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_VoiceData.audio)
  return _internal_audio();
}
inline void CCLCMsg_VoiceData::unsafe_arena_set_allocated_audio(
    ::CMsgVoiceAudio* audio) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.audio_);
  }
  _impl_.audio_ = audio;
  if (audio) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CCLCMsg_VoiceData.audio)
}
inline ::CMsgVoiceAudio* CCLCMsg_VoiceData::release_audio() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVoiceAudio* temp = _impl_.audio_;
  _impl_.audio_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVoiceAudio* CCLCMsg_VoiceData::unsafe_arena_release_audio() {
  // @@protoc_insertion_point(field_release:CCLCMsg_VoiceData.audio)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVoiceAudio* temp = _impl_.audio_;
  _impl_.audio_ = nullptr;
  return temp;
}
inline ::CMsgVoiceAudio* CCLCMsg_VoiceData::_internal_mutable_audio() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.audio_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVoiceAudio>(GetArenaForAllocation());
    _impl_.audio_ = p;
  }
  return _impl_.audio_;
}
inline ::CMsgVoiceAudio* CCLCMsg_VoiceData::mutable_audio() {
  ::CMsgVoiceAudio* _msg = _internal_mutable_audio();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_VoiceData.audio)
  return _msg;
}
inline void CCLCMsg_VoiceData::set_allocated_audio(::CMsgVoiceAudio* audio) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.audio_;
  }
  if (audio) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(audio);
    if (message_arena != submessage_arena) {
      audio = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, audio, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.audio_ = audio;
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_VoiceData.audio)
}

// optional fixed64 xuid = 2;
inline bool CCLCMsg_VoiceData::_internal_has_xuid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CCLCMsg_VoiceData::has_xuid() const {
  return _internal_has_xuid();
}
inline void CCLCMsg_VoiceData::clear_xuid() {
  _impl_.xuid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CCLCMsg_VoiceData::_internal_xuid() const {
  return _impl_.xuid_;
}
inline uint64_t CCLCMsg_VoiceData::xuid() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_VoiceData.xuid)
  return _internal_xuid();
}
inline void CCLCMsg_VoiceData::_internal_set_xuid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.xuid_ = value;
}
inline void CCLCMsg_VoiceData::set_xuid(uint64_t value) {
  _internal_set_xuid(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_VoiceData.xuid)
}

// optional uint32 tick = 3;
inline bool CCLCMsg_VoiceData::_internal_has_tick() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CCLCMsg_VoiceData::has_tick() const {
  return _internal_has_tick();
}
inline void CCLCMsg_VoiceData::clear_tick() {
  _impl_.tick_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CCLCMsg_VoiceData::_internal_tick() const {
  return _impl_.tick_;
}
inline uint32_t CCLCMsg_VoiceData::tick() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_VoiceData.tick)
  return _internal_tick();
}
inline void CCLCMsg_VoiceData::_internal_set_tick(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.tick_ = value;
}
inline void CCLCMsg_VoiceData::set_tick(uint32_t value) {
  _internal_set_tick(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_VoiceData.tick)
}

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

// CCLCMsg_BaselineAck

// optional int32 baseline_tick = 1;
inline bool CCLCMsg_BaselineAck::_internal_has_baseline_tick() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CCLCMsg_BaselineAck::has_baseline_tick() const {
  return _internal_has_baseline_tick();
}
inline void CCLCMsg_BaselineAck::clear_baseline_tick() {
  _impl_.baseline_tick_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CCLCMsg_BaselineAck::_internal_baseline_tick() const {
  return _impl_.baseline_tick_;
}
inline int32_t CCLCMsg_BaselineAck::baseline_tick() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_BaselineAck.baseline_tick)
  return _internal_baseline_tick();
}
inline void CCLCMsg_BaselineAck::_internal_set_baseline_tick(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.baseline_tick_ = value;
}
inline void CCLCMsg_BaselineAck::set_baseline_tick(int32_t value) {
  _internal_set_baseline_tick(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_BaselineAck.baseline_tick)
}

// optional int32 baseline_nr = 2;
inline bool CCLCMsg_BaselineAck::_internal_has_baseline_nr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CCLCMsg_BaselineAck::has_baseline_nr() const {
  return _internal_has_baseline_nr();
}
inline void CCLCMsg_BaselineAck::clear_baseline_nr() {
  _impl_.baseline_nr_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CCLCMsg_BaselineAck::_internal_baseline_nr() const {
  return _impl_.baseline_nr_;
}
inline int32_t CCLCMsg_BaselineAck::baseline_nr() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_BaselineAck.baseline_nr)
  return _internal_baseline_nr();
}
inline void CCLCMsg_BaselineAck::_internal_set_baseline_nr(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.baseline_nr_ = value;
}
inline void CCLCMsg_BaselineAck::set_baseline_nr(int32_t value) {
  _internal_set_baseline_nr(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_BaselineAck.baseline_nr)
}

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

// CCLCMsg_ListenEvents

// repeated fixed32 event_mask = 1;
inline int CCLCMsg_ListenEvents::_internal_event_mask_size() const {
  return _impl_.event_mask_.size();
}
inline int CCLCMsg_ListenEvents::event_mask_size() const {
  return _internal_event_mask_size();
}
inline void CCLCMsg_ListenEvents::clear_event_mask() {
  _impl_.event_mask_.Clear();
}
inline uint32_t CCLCMsg_ListenEvents::_internal_event_mask(int index) const {
  return _impl_.event_mask_.Get(index);
}
inline uint32_t CCLCMsg_ListenEvents::event_mask(int index) const {
  // @@protoc_insertion_point(field_get:CCLCMsg_ListenEvents.event_mask)
  return _internal_event_mask(index);
}
inline void CCLCMsg_ListenEvents::set_event_mask(int index, uint32_t value) {
  _impl_.event_mask_.Set(index, value);
  // @@protoc_insertion_point(field_set:CCLCMsg_ListenEvents.event_mask)
}
inline void CCLCMsg_ListenEvents::_internal_add_event_mask(uint32_t value) {
  _impl_.event_mask_.Add(value);
}
inline void CCLCMsg_ListenEvents::add_event_mask(uint32_t value) {
  _internal_add_event_mask(value);
  // @@protoc_insertion_point(field_add:CCLCMsg_ListenEvents.event_mask)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CCLCMsg_ListenEvents::_internal_event_mask() const {
  return _impl_.event_mask_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CCLCMsg_ListenEvents::event_mask() const {
  // @@protoc_insertion_point(field_list:CCLCMsg_ListenEvents.event_mask)
  return _internal_event_mask();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CCLCMsg_ListenEvents::_internal_mutable_event_mask() {
  return &_impl_.event_mask_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CCLCMsg_ListenEvents::mutable_event_mask() {
  // @@protoc_insertion_point(field_mutable_list:CCLCMsg_ListenEvents.event_mask)
  return _internal_mutable_event_mask();
}

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

// CCLCMsg_RespondCvarValue

// optional int32 cookie = 1;
inline bool CCLCMsg_RespondCvarValue::_internal_has_cookie() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CCLCMsg_RespondCvarValue::has_cookie() const {
  return _internal_has_cookie();
}
inline void CCLCMsg_RespondCvarValue::clear_cookie() {
  _impl_.cookie_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CCLCMsg_RespondCvarValue::_internal_cookie() const {
  return _impl_.cookie_;
}
inline int32_t CCLCMsg_RespondCvarValue::cookie() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_RespondCvarValue.cookie)
  return _internal_cookie();
}
inline void CCLCMsg_RespondCvarValue::_internal_set_cookie(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.cookie_ = value;
}
inline void CCLCMsg_RespondCvarValue::set_cookie(int32_t value) {
  _internal_set_cookie(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_RespondCvarValue.cookie)
}

// optional int32 status_code = 2;
inline bool CCLCMsg_RespondCvarValue::_internal_has_status_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CCLCMsg_RespondCvarValue::has_status_code() const {
  return _internal_has_status_code();
}
inline void CCLCMsg_RespondCvarValue::clear_status_code() {
  _impl_.status_code_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CCLCMsg_RespondCvarValue::_internal_status_code() const {
  return _impl_.status_code_;
}
inline int32_t CCLCMsg_RespondCvarValue::status_code() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_RespondCvarValue.status_code)
  return _internal_status_code();
}
inline void CCLCMsg_RespondCvarValue::_internal_set_status_code(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.status_code_ = value;
}
inline void CCLCMsg_RespondCvarValue::set_status_code(int32_t value) {
  _internal_set_status_code(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_RespondCvarValue.status_code)
}

// optional string name = 3;
inline bool CCLCMsg_RespondCvarValue::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CCLCMsg_RespondCvarValue::has_name() const {
  return _internal_has_name();
}
inline void CCLCMsg_RespondCvarValue::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CCLCMsg_RespondCvarValue::name() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_RespondCvarValue.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CCLCMsg_RespondCvarValue::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CCLCMsg_RespondCvarValue.name)
}
inline std::string* CCLCMsg_RespondCvarValue::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_RespondCvarValue.name)
  return _s;
}
inline const std::string& CCLCMsg_RespondCvarValue::_internal_name() const {
  return _impl_.name_.Get();
}
inline void CCLCMsg_RespondCvarValue::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* CCLCMsg_RespondCvarValue::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* CCLCMsg_RespondCvarValue::release_name() {
  // @@protoc_insertion_point(field_release:CCLCMsg_RespondCvarValue.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CCLCMsg_RespondCvarValue::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_RespondCvarValue.name)
}

// optional string value = 4;
inline bool CCLCMsg_RespondCvarValue::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CCLCMsg_RespondCvarValue::has_value() const {
  return _internal_has_value();
}
inline void CCLCMsg_RespondCvarValue::clear_value() {
  _impl_.value_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CCLCMsg_RespondCvarValue::value() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_RespondCvarValue.value)
  return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CCLCMsg_RespondCvarValue::set_value(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CCLCMsg_RespondCvarValue.value)
}
inline std::string* CCLCMsg_RespondCvarValue::mutable_value() {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_RespondCvarValue.value)
  return _s;
}
inline const std::string& CCLCMsg_RespondCvarValue::_internal_value() const {
  return _impl_.value_.Get();
}
inline void CCLCMsg_RespondCvarValue::_internal_set_value(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* CCLCMsg_RespondCvarValue::_internal_mutable_value() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* CCLCMsg_RespondCvarValue::release_value() {
  // @@protoc_insertion_point(field_release:CCLCMsg_RespondCvarValue.value)
  if (!_internal_has_value()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.value_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CCLCMsg_RespondCvarValue::set_allocated_value(std::string* value) {
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_RespondCvarValue.value)
}

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

// CCLCMsg_LoadingProgress

// optional int32 progress = 1;
inline bool CCLCMsg_LoadingProgress::_internal_has_progress() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CCLCMsg_LoadingProgress::has_progress() const {
  return _internal_has_progress();
}
inline void CCLCMsg_LoadingProgress::clear_progress() {
  _impl_.progress_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CCLCMsg_LoadingProgress::_internal_progress() const {
  return _impl_.progress_;
}
inline int32_t CCLCMsg_LoadingProgress::progress() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_LoadingProgress.progress)
  return _internal_progress();
}
inline void CCLCMsg_LoadingProgress::_internal_set_progress(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.progress_ = value;
}
inline void CCLCMsg_LoadingProgress::set_progress(int32_t value) {
  _internal_set_progress(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_LoadingProgress.progress)
}

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

// CCLCMsg_SplitPlayerConnect

// optional string playername = 1;
inline bool CCLCMsg_SplitPlayerConnect::_internal_has_playername() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CCLCMsg_SplitPlayerConnect::has_playername() const {
  return _internal_has_playername();
}
inline void CCLCMsg_SplitPlayerConnect::clear_playername() {
  _impl_.playername_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CCLCMsg_SplitPlayerConnect::playername() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_SplitPlayerConnect.playername)
  return _internal_playername();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CCLCMsg_SplitPlayerConnect::set_playername(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.playername_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CCLCMsg_SplitPlayerConnect.playername)
}
inline std::string* CCLCMsg_SplitPlayerConnect::mutable_playername() {
  std::string* _s = _internal_mutable_playername();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_SplitPlayerConnect.playername)
  return _s;
}
inline const std::string& CCLCMsg_SplitPlayerConnect::_internal_playername() const {
  return _impl_.playername_.Get();
}
inline void CCLCMsg_SplitPlayerConnect::_internal_set_playername(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.playername_.Set(value, GetArenaForAllocation());
}
inline std::string* CCLCMsg_SplitPlayerConnect::_internal_mutable_playername() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.playername_.Mutable(GetArenaForAllocation());
}
inline std::string* CCLCMsg_SplitPlayerConnect::release_playername() {
  // @@protoc_insertion_point(field_release:CCLCMsg_SplitPlayerConnect.playername)
  if (!_internal_has_playername()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.playername_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.playername_.IsDefault()) {
    _impl_.playername_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CCLCMsg_SplitPlayerConnect::set_allocated_playername(std::string* playername) {
  if (playername != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.playername_.SetAllocated(playername, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.playername_.IsDefault()) {
    _impl_.playername_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_SplitPlayerConnect.playername)
}

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

// CCLCMsg_SplitPlayerDisconnect

// optional int32 slot = 1;
inline bool CCLCMsg_SplitPlayerDisconnect::_internal_has_slot() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CCLCMsg_SplitPlayerDisconnect::has_slot() const {
  return _internal_has_slot();
}
inline void CCLCMsg_SplitPlayerDisconnect::clear_slot() {
  _impl_.slot_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CCLCMsg_SplitPlayerDisconnect::_internal_slot() const {
  return _impl_.slot_;
}
inline int32_t CCLCMsg_SplitPlayerDisconnect::slot() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_SplitPlayerDisconnect.slot)
  return _internal_slot();
}
inline void CCLCMsg_SplitPlayerDisconnect::_internal_set_slot(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.slot_ = value;
}
inline void CCLCMsg_SplitPlayerDisconnect::set_slot(int32_t value) {
  _internal_set_slot(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_SplitPlayerDisconnect.slot)
}

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

// CCLCMsg_ServerStatus

// optional bool simplified = 1;
inline bool CCLCMsg_ServerStatus::_internal_has_simplified() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CCLCMsg_ServerStatus::has_simplified() const {
  return _internal_has_simplified();
}
inline void CCLCMsg_ServerStatus::clear_simplified() {
  _impl_.simplified_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CCLCMsg_ServerStatus::_internal_simplified() const {
  return _impl_.simplified_;
}
inline bool CCLCMsg_ServerStatus::simplified() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_ServerStatus.simplified)
  return _internal_simplified();
}
inline void CCLCMsg_ServerStatus::_internal_set_simplified(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.simplified_ = value;
}
inline void CCLCMsg_ServerStatus::set_simplified(bool value) {
  _internal_set_simplified(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_ServerStatus.simplified)
}

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

// CCLCMsg_RequestPause

// optional .RequestPause_t pause_type = 1 [default = RP_PAUSE];
inline bool CCLCMsg_RequestPause::_internal_has_pause_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CCLCMsg_RequestPause::has_pause_type() const {
  return _internal_has_pause_type();
}
inline void CCLCMsg_RequestPause::clear_pause_type() {
  _impl_.pause_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::RequestPause_t CCLCMsg_RequestPause::_internal_pause_type() const {
  return static_cast< ::RequestPause_t >(_impl_.pause_type_);
}
inline ::RequestPause_t CCLCMsg_RequestPause::pause_type() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_RequestPause.pause_type)
  return _internal_pause_type();
}
inline void CCLCMsg_RequestPause::_internal_set_pause_type(::RequestPause_t value) {
  assert(::RequestPause_t_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.pause_type_ = value;
}
inline void CCLCMsg_RequestPause::set_pause_type(::RequestPause_t value) {
  _internal_set_pause_type(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_RequestPause.pause_type)
}

// optional int32 pause_group = 2;
inline bool CCLCMsg_RequestPause::_internal_has_pause_group() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CCLCMsg_RequestPause::has_pause_group() const {
  return _internal_has_pause_group();
}
inline void CCLCMsg_RequestPause::clear_pause_group() {
  _impl_.pause_group_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CCLCMsg_RequestPause::_internal_pause_group() const {
  return _impl_.pause_group_;
}
inline int32_t CCLCMsg_RequestPause::pause_group() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_RequestPause.pause_group)
  return _internal_pause_group();
}
inline void CCLCMsg_RequestPause::_internal_set_pause_group(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.pause_group_ = value;
}
inline void CCLCMsg_RequestPause::set_pause_group(int32_t value) {
  _internal_set_pause_group(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_RequestPause.pause_group)
}

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

// CCLCMsg_CmdKeyValues

// optional bytes data = 1;
inline bool CCLCMsg_CmdKeyValues::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CCLCMsg_CmdKeyValues::has_data() const {
  return _internal_has_data();
}
inline void CCLCMsg_CmdKeyValues::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CCLCMsg_CmdKeyValues::data() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_CmdKeyValues.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CCLCMsg_CmdKeyValues::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CCLCMsg_CmdKeyValues.data)
}
inline std::string* CCLCMsg_CmdKeyValues::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_CmdKeyValues.data)
  return _s;
}
inline const std::string& CCLCMsg_CmdKeyValues::_internal_data() const {
  return _impl_.data_.Get();
}
inline void CCLCMsg_CmdKeyValues::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* CCLCMsg_CmdKeyValues::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* CCLCMsg_CmdKeyValues::release_data() {
  // @@protoc_insertion_point(field_release:CCLCMsg_CmdKeyValues.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CCLCMsg_CmdKeyValues::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_CmdKeyValues.data)
}

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

// CCLCMsg_RconServerDetails

// optional bytes token = 1;
inline bool CCLCMsg_RconServerDetails::_internal_has_token() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CCLCMsg_RconServerDetails::has_token() const {
  return _internal_has_token();
}
inline void CCLCMsg_RconServerDetails::clear_token() {
  _impl_.token_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CCLCMsg_RconServerDetails::token() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_RconServerDetails.token)
  return _internal_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CCLCMsg_RconServerDetails::set_token(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.token_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CCLCMsg_RconServerDetails.token)
}
inline std::string* CCLCMsg_RconServerDetails::mutable_token() {
  std::string* _s = _internal_mutable_token();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_RconServerDetails.token)
  return _s;
}
inline const std::string& CCLCMsg_RconServerDetails::_internal_token() const {
  return _impl_.token_.Get();
}
inline void CCLCMsg_RconServerDetails::_internal_set_token(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.token_.Set(value, GetArenaForAllocation());
}
inline std::string* CCLCMsg_RconServerDetails::_internal_mutable_token() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.token_.Mutable(GetArenaForAllocation());
}
inline std::string* CCLCMsg_RconServerDetails::release_token() {
  // @@protoc_insertion_point(field_release:CCLCMsg_RconServerDetails.token)
  if (!_internal_has_token()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.token_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.token_.IsDefault()) {
    _impl_.token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CCLCMsg_RconServerDetails::set_allocated_token(std::string* token) {
  if (token != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.token_.SetAllocated(token, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.token_.IsDefault()) {
    _impl_.token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_RconServerDetails.token)
}

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

// CCLCMsg_Diagnostic

// optional .CMsgSource2SystemSpecs system_specs = 1;
inline bool CCLCMsg_Diagnostic::_internal_has_system_specs() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.system_specs_ != nullptr);
  return value;
}
inline bool CCLCMsg_Diagnostic::has_system_specs() const {
  return _internal_has_system_specs();
}
inline const ::CMsgSource2SystemSpecs& CCLCMsg_Diagnostic::_internal_system_specs() const {
  const ::CMsgSource2SystemSpecs* p = _impl_.system_specs_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSource2SystemSpecs&>(
      ::_CMsgSource2SystemSpecs_default_instance_);
}
inline const ::CMsgSource2SystemSpecs& CCLCMsg_Diagnostic::system_specs() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_Diagnostic.system_specs)
  return _internal_system_specs();
}
inline void CCLCMsg_Diagnostic::unsafe_arena_set_allocated_system_specs(
    ::CMsgSource2SystemSpecs* system_specs) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.system_specs_);
  }
  _impl_.system_specs_ = system_specs;
  if (system_specs) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CCLCMsg_Diagnostic.system_specs)
}
inline ::CMsgSource2SystemSpecs* CCLCMsg_Diagnostic::release_system_specs() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSource2SystemSpecs* temp = _impl_.system_specs_;
  _impl_.system_specs_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgSource2SystemSpecs* CCLCMsg_Diagnostic::unsafe_arena_release_system_specs() {
  // @@protoc_insertion_point(field_release:CCLCMsg_Diagnostic.system_specs)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSource2SystemSpecs* temp = _impl_.system_specs_;
  _impl_.system_specs_ = nullptr;
  return temp;
}
inline ::CMsgSource2SystemSpecs* CCLCMsg_Diagnostic::_internal_mutable_system_specs() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.system_specs_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSource2SystemSpecs>(GetArenaForAllocation());
    _impl_.system_specs_ = p;
  }
  return _impl_.system_specs_;
}
inline ::CMsgSource2SystemSpecs* CCLCMsg_Diagnostic::mutable_system_specs() {
  ::CMsgSource2SystemSpecs* _msg = _internal_mutable_system_specs();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_Diagnostic.system_specs)
  return _msg;
}
inline void CCLCMsg_Diagnostic::set_allocated_system_specs(::CMsgSource2SystemSpecs* system_specs) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.system_specs_);
  }
  if (system_specs) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(system_specs));
    if (message_arena != submessage_arena) {
      system_specs = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, system_specs, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.system_specs_ = system_specs;
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_Diagnostic.system_specs)
}

// optional .CMsgSource2VProfLiteReport vprof_report = 2;
inline bool CCLCMsg_Diagnostic::_internal_has_vprof_report() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.vprof_report_ != nullptr);
  return value;
}
inline bool CCLCMsg_Diagnostic::has_vprof_report() const {
  return _internal_has_vprof_report();
}
inline const ::CMsgSource2VProfLiteReport& CCLCMsg_Diagnostic::_internal_vprof_report() const {
  const ::CMsgSource2VProfLiteReport* p = _impl_.vprof_report_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSource2VProfLiteReport&>(
      ::_CMsgSource2VProfLiteReport_default_instance_);
}
inline const ::CMsgSource2VProfLiteReport& CCLCMsg_Diagnostic::vprof_report() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_Diagnostic.vprof_report)
  return _internal_vprof_report();
}
inline void CCLCMsg_Diagnostic::unsafe_arena_set_allocated_vprof_report(
    ::CMsgSource2VProfLiteReport* vprof_report) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vprof_report_);
  }
  _impl_.vprof_report_ = vprof_report;
  if (vprof_report) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CCLCMsg_Diagnostic.vprof_report)
}
inline ::CMsgSource2VProfLiteReport* CCLCMsg_Diagnostic::release_vprof_report() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSource2VProfLiteReport* temp = _impl_.vprof_report_;
  _impl_.vprof_report_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgSource2VProfLiteReport* CCLCMsg_Diagnostic::unsafe_arena_release_vprof_report() {
  // @@protoc_insertion_point(field_release:CCLCMsg_Diagnostic.vprof_report)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSource2VProfLiteReport* temp = _impl_.vprof_report_;
  _impl_.vprof_report_ = nullptr;
  return temp;
}
inline ::CMsgSource2VProfLiteReport* CCLCMsg_Diagnostic::_internal_mutable_vprof_report() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.vprof_report_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSource2VProfLiteReport>(GetArenaForAllocation());
    _impl_.vprof_report_ = p;
  }
  return _impl_.vprof_report_;
}
inline ::CMsgSource2VProfLiteReport* CCLCMsg_Diagnostic::mutable_vprof_report() {
  ::CMsgSource2VProfLiteReport* _msg = _internal_mutable_vprof_report();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_Diagnostic.vprof_report)
  return _msg;
}
inline void CCLCMsg_Diagnostic::set_allocated_vprof_report(::CMsgSource2VProfLiteReport* vprof_report) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vprof_report_);
  }
  if (vprof_report) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(vprof_report));
    if (message_arena != submessage_arena) {
      vprof_report = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, vprof_report, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.vprof_report_ = vprof_report;
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_Diagnostic.vprof_report)
}

// optional .CMsgSource2NetworkFlowQuality downstream_flow = 3;
inline bool CCLCMsg_Diagnostic::_internal_has_downstream_flow() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.downstream_flow_ != nullptr);
  return value;
}
inline bool CCLCMsg_Diagnostic::has_downstream_flow() const {
  return _internal_has_downstream_flow();
}
inline const ::CMsgSource2NetworkFlowQuality& CCLCMsg_Diagnostic::_internal_downstream_flow() const {
  const ::CMsgSource2NetworkFlowQuality* p = _impl_.downstream_flow_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSource2NetworkFlowQuality&>(
      ::_CMsgSource2NetworkFlowQuality_default_instance_);
}
inline const ::CMsgSource2NetworkFlowQuality& CCLCMsg_Diagnostic::downstream_flow() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_Diagnostic.downstream_flow)
  return _internal_downstream_flow();
}
inline void CCLCMsg_Diagnostic::unsafe_arena_set_allocated_downstream_flow(
    ::CMsgSource2NetworkFlowQuality* downstream_flow) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.downstream_flow_);
  }
  _impl_.downstream_flow_ = downstream_flow;
  if (downstream_flow) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CCLCMsg_Diagnostic.downstream_flow)
}
inline ::CMsgSource2NetworkFlowQuality* CCLCMsg_Diagnostic::release_downstream_flow() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgSource2NetworkFlowQuality* temp = _impl_.downstream_flow_;
  _impl_.downstream_flow_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgSource2NetworkFlowQuality* CCLCMsg_Diagnostic::unsafe_arena_release_downstream_flow() {
  // @@protoc_insertion_point(field_release:CCLCMsg_Diagnostic.downstream_flow)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgSource2NetworkFlowQuality* temp = _impl_.downstream_flow_;
  _impl_.downstream_flow_ = nullptr;
  return temp;
}
inline ::CMsgSource2NetworkFlowQuality* CCLCMsg_Diagnostic::_internal_mutable_downstream_flow() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.downstream_flow_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSource2NetworkFlowQuality>(GetArenaForAllocation());
    _impl_.downstream_flow_ = p;
  }
  return _impl_.downstream_flow_;
}
inline ::CMsgSource2NetworkFlowQuality* CCLCMsg_Diagnostic::mutable_downstream_flow() {
  ::CMsgSource2NetworkFlowQuality* _msg = _internal_mutable_downstream_flow();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_Diagnostic.downstream_flow)
  return _msg;
}
inline void CCLCMsg_Diagnostic::set_allocated_downstream_flow(::CMsgSource2NetworkFlowQuality* downstream_flow) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.downstream_flow_);
  }
  if (downstream_flow) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(downstream_flow));
    if (message_arena != submessage_arena) {
      downstream_flow = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, downstream_flow, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.downstream_flow_ = downstream_flow;
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_Diagnostic.downstream_flow)
}

// optional .CMsgSource2NetworkFlowQuality upstream_flow = 4;
inline bool CCLCMsg_Diagnostic::_internal_has_upstream_flow() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.upstream_flow_ != nullptr);
  return value;
}
inline bool CCLCMsg_Diagnostic::has_upstream_flow() const {
  return _internal_has_upstream_flow();
}
inline const ::CMsgSource2NetworkFlowQuality& CCLCMsg_Diagnostic::_internal_upstream_flow() const {
  const ::CMsgSource2NetworkFlowQuality* p = _impl_.upstream_flow_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSource2NetworkFlowQuality&>(
      ::_CMsgSource2NetworkFlowQuality_default_instance_);
}
inline const ::CMsgSource2NetworkFlowQuality& CCLCMsg_Diagnostic::upstream_flow() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_Diagnostic.upstream_flow)
  return _internal_upstream_flow();
}
inline void CCLCMsg_Diagnostic::unsafe_arena_set_allocated_upstream_flow(
    ::CMsgSource2NetworkFlowQuality* upstream_flow) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.upstream_flow_);
  }
  _impl_.upstream_flow_ = upstream_flow;
  if (upstream_flow) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CCLCMsg_Diagnostic.upstream_flow)
}
inline ::CMsgSource2NetworkFlowQuality* CCLCMsg_Diagnostic::release_upstream_flow() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgSource2NetworkFlowQuality* temp = _impl_.upstream_flow_;
  _impl_.upstream_flow_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgSource2NetworkFlowQuality* CCLCMsg_Diagnostic::unsafe_arena_release_upstream_flow() {
  // @@protoc_insertion_point(field_release:CCLCMsg_Diagnostic.upstream_flow)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgSource2NetworkFlowQuality* temp = _impl_.upstream_flow_;
  _impl_.upstream_flow_ = nullptr;
  return temp;
}
inline ::CMsgSource2NetworkFlowQuality* CCLCMsg_Diagnostic::_internal_mutable_upstream_flow() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.upstream_flow_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSource2NetworkFlowQuality>(GetArenaForAllocation());
    _impl_.upstream_flow_ = p;
  }
  return _impl_.upstream_flow_;
}
inline ::CMsgSource2NetworkFlowQuality* CCLCMsg_Diagnostic::mutable_upstream_flow() {
  ::CMsgSource2NetworkFlowQuality* _msg = _internal_mutable_upstream_flow();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_Diagnostic.upstream_flow)
  return _msg;
}
inline void CCLCMsg_Diagnostic::set_allocated_upstream_flow(::CMsgSource2NetworkFlowQuality* upstream_flow) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.upstream_flow_);
  }
  if (upstream_flow) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(upstream_flow));
    if (message_arena != submessage_arena) {
      upstream_flow = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, upstream_flow, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.upstream_flow_ = upstream_flow;
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_Diagnostic.upstream_flow)
}

// repeated .CMsgSource2PerfIntervalSample perf_samples = 5;
inline int CCLCMsg_Diagnostic::_internal_perf_samples_size() const {
  return _impl_.perf_samples_.size();
}
inline int CCLCMsg_Diagnostic::perf_samples_size() const {
  return _internal_perf_samples_size();
}
inline ::CMsgSource2PerfIntervalSample* CCLCMsg_Diagnostic::mutable_perf_samples(int index) {
  // @@protoc_insertion_point(field_mutable:CCLCMsg_Diagnostic.perf_samples)
  return _impl_.perf_samples_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSource2PerfIntervalSample >*
CCLCMsg_Diagnostic::mutable_perf_samples() {
  // @@protoc_insertion_point(field_mutable_list:CCLCMsg_Diagnostic.perf_samples)
  return &_impl_.perf_samples_;
}
inline const ::CMsgSource2PerfIntervalSample& CCLCMsg_Diagnostic::_internal_perf_samples(int index) const {
  return _impl_.perf_samples_.Get(index);
}
inline const ::CMsgSource2PerfIntervalSample& CCLCMsg_Diagnostic::perf_samples(int index) const {
  // @@protoc_insertion_point(field_get:CCLCMsg_Diagnostic.perf_samples)
  return _internal_perf_samples(index);
}
inline ::CMsgSource2PerfIntervalSample* CCLCMsg_Diagnostic::_internal_add_perf_samples() {
  return _impl_.perf_samples_.Add();
}
inline ::CMsgSource2PerfIntervalSample* CCLCMsg_Diagnostic::add_perf_samples() {
  ::CMsgSource2PerfIntervalSample* _add = _internal_add_perf_samples();
  // @@protoc_insertion_point(field_add:CCLCMsg_Diagnostic.perf_samples)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSource2PerfIntervalSample >&
CCLCMsg_Diagnostic::perf_samples() const {
  // @@protoc_insertion_point(field_list:CCLCMsg_Diagnostic.perf_samples)
  return _impl_.perf_samples_;
}

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

// CSVCMsg_ServerInfo

// optional int32 protocol = 1;
inline bool CSVCMsg_ServerInfo::_internal_has_protocol() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CSVCMsg_ServerInfo::has_protocol() const {
  return _internal_has_protocol();
}
inline void CSVCMsg_ServerInfo::clear_protocol() {
  _impl_.protocol_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t CSVCMsg_ServerInfo::_internal_protocol() const {
  return _impl_.protocol_;
}
inline int32_t CSVCMsg_ServerInfo::protocol() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.protocol)
  return _internal_protocol();
}
inline void CSVCMsg_ServerInfo::_internal_set_protocol(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.protocol_ = value;
}
inline void CSVCMsg_ServerInfo::set_protocol(int32_t value) {
  _internal_set_protocol(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerInfo.protocol)
}

// optional int32 server_count = 2;
inline bool CSVCMsg_ServerInfo::_internal_has_server_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CSVCMsg_ServerInfo::has_server_count() const {
  return _internal_has_server_count();
}
inline void CSVCMsg_ServerInfo::clear_server_count() {
  _impl_.server_count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int32_t CSVCMsg_ServerInfo::_internal_server_count() const {
  return _impl_.server_count_;
}
inline int32_t CSVCMsg_ServerInfo::server_count() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.server_count)
  return _internal_server_count();
}
inline void CSVCMsg_ServerInfo::_internal_set_server_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.server_count_ = value;
}
inline void CSVCMsg_ServerInfo::set_server_count(int32_t value) {
  _internal_set_server_count(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerInfo.server_count)
}

// optional bool is_dedicated = 3;
inline bool CSVCMsg_ServerInfo::_internal_has_is_dedicated() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CSVCMsg_ServerInfo::has_is_dedicated() const {
  return _internal_has_is_dedicated();
}
inline void CSVCMsg_ServerInfo::clear_is_dedicated() {
  _impl_.is_dedicated_ = false;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline bool CSVCMsg_ServerInfo::_internal_is_dedicated() const {
  return _impl_.is_dedicated_;
}
inline bool CSVCMsg_ServerInfo::is_dedicated() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.is_dedicated)
  return _internal_is_dedicated();
}
inline void CSVCMsg_ServerInfo::_internal_set_is_dedicated(bool value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.is_dedicated_ = value;
}
inline void CSVCMsg_ServerInfo::set_is_dedicated(bool value) {
  _internal_set_is_dedicated(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerInfo.is_dedicated)
}

// optional bool is_hltv = 4;
inline bool CSVCMsg_ServerInfo::_internal_has_is_hltv() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CSVCMsg_ServerInfo::has_is_hltv() const {
  return _internal_has_is_hltv();
}
inline void CSVCMsg_ServerInfo::clear_is_hltv() {
  _impl_.is_hltv_ = false;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline bool CSVCMsg_ServerInfo::_internal_is_hltv() const {
  return _impl_.is_hltv_;
}
inline bool CSVCMsg_ServerInfo::is_hltv() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.is_hltv)
  return _internal_is_hltv();
}
inline void CSVCMsg_ServerInfo::_internal_set_is_hltv(bool value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.is_hltv_ = value;
}
inline void CSVCMsg_ServerInfo::set_is_hltv(bool value) {
  _internal_set_is_hltv(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerInfo.is_hltv)
}

// optional int32 c_os = 6;
inline bool CSVCMsg_ServerInfo::_internal_has_c_os() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CSVCMsg_ServerInfo::has_c_os() const {
  return _internal_has_c_os();
}
inline void CSVCMsg_ServerInfo::clear_c_os() {
  _impl_.c_os_ = 0;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline int32_t CSVCMsg_ServerInfo::_internal_c_os() const {
  return _impl_.c_os_;
}
inline int32_t CSVCMsg_ServerInfo::c_os() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.c_os)
  return _internal_c_os();
}
inline void CSVCMsg_ServerInfo::_internal_set_c_os(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.c_os_ = value;
}
inline void CSVCMsg_ServerInfo::set_c_os(int32_t value) {
  _internal_set_c_os(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerInfo.c_os)
}

// optional int32 max_clients = 10;
inline bool CSVCMsg_ServerInfo::_internal_has_max_clients() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CSVCMsg_ServerInfo::has_max_clients() const {
  return _internal_has_max_clients();
}
inline void CSVCMsg_ServerInfo::clear_max_clients() {
  _impl_.max_clients_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline int32_t CSVCMsg_ServerInfo::_internal_max_clients() const {
  return _impl_.max_clients_;
}
inline int32_t CSVCMsg_ServerInfo::max_clients() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.max_clients)
  return _internal_max_clients();
}
inline void CSVCMsg_ServerInfo::_internal_set_max_clients(int32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.max_clients_ = value;
}
inline void CSVCMsg_ServerInfo::set_max_clients(int32_t value) {
  _internal_set_max_clients(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerInfo.max_clients)
}

// optional int32 max_classes = 11;
inline bool CSVCMsg_ServerInfo::_internal_has_max_classes() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CSVCMsg_ServerInfo::has_max_classes() const {
  return _internal_has_max_classes();
}
inline void CSVCMsg_ServerInfo::clear_max_classes() {
  _impl_.max_classes_ = 0;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline int32_t CSVCMsg_ServerInfo::_internal_max_classes() const {
  return _impl_.max_classes_;
}
inline int32_t CSVCMsg_ServerInfo::max_classes() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.max_classes)
  return _internal_max_classes();
}
inline void CSVCMsg_ServerInfo::_internal_set_max_classes(int32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.max_classes_ = value;
}
inline void CSVCMsg_ServerInfo::set_max_classes(int32_t value) {
  _internal_set_max_classes(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerInfo.max_classes)
}

// optional int32 player_slot = 12 [default = -1];
inline bool CSVCMsg_ServerInfo::_internal_has_player_slot() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool CSVCMsg_ServerInfo::has_player_slot() const {
  return _internal_has_player_slot();
}
inline void CSVCMsg_ServerInfo::clear_player_slot() {
  _impl_.player_slot_ = -1;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline int32_t CSVCMsg_ServerInfo::_internal_player_slot() const {
  return _impl_.player_slot_;
}
inline int32_t CSVCMsg_ServerInfo::player_slot() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.player_slot)
  return _internal_player_slot();
}
inline void CSVCMsg_ServerInfo::_internal_set_player_slot(int32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.player_slot_ = value;
}
inline void CSVCMsg_ServerInfo::set_player_slot(int32_t value) {
  _internal_set_player_slot(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerInfo.player_slot)
}

// optional float tick_interval = 13;
inline bool CSVCMsg_ServerInfo::_internal_has_tick_interval() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CSVCMsg_ServerInfo::has_tick_interval() const {
  return _internal_has_tick_interval();
}
inline void CSVCMsg_ServerInfo::clear_tick_interval() {
  _impl_.tick_interval_ = 0;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline float CSVCMsg_ServerInfo::_internal_tick_interval() const {
  return _impl_.tick_interval_;
}
inline float CSVCMsg_ServerInfo::tick_interval() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.tick_interval)
  return _internal_tick_interval();
}
inline void CSVCMsg_ServerInfo::_internal_set_tick_interval(float value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.tick_interval_ = value;
}
inline void CSVCMsg_ServerInfo::set_tick_interval(float value) {
  _internal_set_tick_interval(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerInfo.tick_interval)
}

// optional string game_dir = 14;
inline bool CSVCMsg_ServerInfo::_internal_has_game_dir() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_ServerInfo::has_game_dir() const {
  return _internal_has_game_dir();
}
inline void CSVCMsg_ServerInfo::clear_game_dir() {
  _impl_.game_dir_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_ServerInfo::game_dir() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.game_dir)
  return _internal_game_dir();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_ServerInfo::set_game_dir(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.game_dir_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerInfo.game_dir)
}
inline std::string* CSVCMsg_ServerInfo::mutable_game_dir() {
  std::string* _s = _internal_mutable_game_dir();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_ServerInfo.game_dir)
  return _s;
}
inline const std::string& CSVCMsg_ServerInfo::_internal_game_dir() const {
  return _impl_.game_dir_.Get();
}
inline void CSVCMsg_ServerInfo::_internal_set_game_dir(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.game_dir_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_ServerInfo::_internal_mutable_game_dir() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.game_dir_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_ServerInfo::release_game_dir() {
  // @@protoc_insertion_point(field_release:CSVCMsg_ServerInfo.game_dir)
  if (!_internal_has_game_dir()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.game_dir_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.game_dir_.IsDefault()) {
    _impl_.game_dir_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_ServerInfo::set_allocated_game_dir(std::string* game_dir) {
  if (game_dir != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.game_dir_.SetAllocated(game_dir, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.game_dir_.IsDefault()) {
    _impl_.game_dir_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_ServerInfo.game_dir)
}

// optional string map_name = 15;
inline bool CSVCMsg_ServerInfo::_internal_has_map_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_ServerInfo::has_map_name() const {
  return _internal_has_map_name();
}
inline void CSVCMsg_ServerInfo::clear_map_name() {
  _impl_.map_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CSVCMsg_ServerInfo::map_name() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.map_name)
  return _internal_map_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_ServerInfo::set_map_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.map_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerInfo.map_name)
}
inline std::string* CSVCMsg_ServerInfo::mutable_map_name() {
  std::string* _s = _internal_mutable_map_name();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_ServerInfo.map_name)
  return _s;
}
inline const std::string& CSVCMsg_ServerInfo::_internal_map_name() const {
  return _impl_.map_name_.Get();
}
inline void CSVCMsg_ServerInfo::_internal_set_map_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.map_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_ServerInfo::_internal_mutable_map_name() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.map_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_ServerInfo::release_map_name() {
  // @@protoc_insertion_point(field_release:CSVCMsg_ServerInfo.map_name)
  if (!_internal_has_map_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.map_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.map_name_.IsDefault()) {
    _impl_.map_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_ServerInfo::set_allocated_map_name(std::string* map_name) {
  if (map_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.map_name_.SetAllocated(map_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.map_name_.IsDefault()) {
    _impl_.map_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_ServerInfo.map_name)
}

// optional string sky_name = 16;
inline bool CSVCMsg_ServerInfo::_internal_has_sky_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_ServerInfo::has_sky_name() const {
  return _internal_has_sky_name();
}
inline void CSVCMsg_ServerInfo::clear_sky_name() {
  _impl_.sky_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CSVCMsg_ServerInfo::sky_name() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.sky_name)
  return _internal_sky_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_ServerInfo::set_sky_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.sky_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerInfo.sky_name)
}
inline std::string* CSVCMsg_ServerInfo::mutable_sky_name() {
  std::string* _s = _internal_mutable_sky_name();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_ServerInfo.sky_name)
  return _s;
}
inline const std::string& CSVCMsg_ServerInfo::_internal_sky_name() const {
  return _impl_.sky_name_.Get();
}
inline void CSVCMsg_ServerInfo::_internal_set_sky_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.sky_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_ServerInfo::_internal_mutable_sky_name() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.sky_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_ServerInfo::release_sky_name() {
  // @@protoc_insertion_point(field_release:CSVCMsg_ServerInfo.sky_name)
  if (!_internal_has_sky_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.sky_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sky_name_.IsDefault()) {
    _impl_.sky_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_ServerInfo::set_allocated_sky_name(std::string* sky_name) {
  if (sky_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.sky_name_.SetAllocated(sky_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sky_name_.IsDefault()) {
    _impl_.sky_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_ServerInfo.sky_name)
}

// optional string host_name = 17;
inline bool CSVCMsg_ServerInfo::_internal_has_host_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSVCMsg_ServerInfo::has_host_name() const {
  return _internal_has_host_name();
}
inline void CSVCMsg_ServerInfo::clear_host_name() {
  _impl_.host_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& CSVCMsg_ServerInfo::host_name() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.host_name)
  return _internal_host_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_ServerInfo::set_host_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.host_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerInfo.host_name)
}
inline std::string* CSVCMsg_ServerInfo::mutable_host_name() {
  std::string* _s = _internal_mutable_host_name();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_ServerInfo.host_name)
  return _s;
}
inline const std::string& CSVCMsg_ServerInfo::_internal_host_name() const {
  return _impl_.host_name_.Get();
}
inline void CSVCMsg_ServerInfo::_internal_set_host_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.host_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_ServerInfo::_internal_mutable_host_name() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.host_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_ServerInfo::release_host_name() {
  // @@protoc_insertion_point(field_release:CSVCMsg_ServerInfo.host_name)
  if (!_internal_has_host_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.host_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.host_name_.IsDefault()) {
    _impl_.host_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_ServerInfo::set_allocated_host_name(std::string* host_name) {
  if (host_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.host_name_.SetAllocated(host_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.host_name_.IsDefault()) {
    _impl_.host_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_ServerInfo.host_name)
}

// optional string addon_name = 18;
inline bool CSVCMsg_ServerInfo::_internal_has_addon_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSVCMsg_ServerInfo::has_addon_name() const {
  return _internal_has_addon_name();
}
inline void CSVCMsg_ServerInfo::clear_addon_name() {
  _impl_.addon_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& CSVCMsg_ServerInfo::addon_name() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.addon_name)
  return _internal_addon_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_ServerInfo::set_addon_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.addon_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerInfo.addon_name)
}
inline std::string* CSVCMsg_ServerInfo::mutable_addon_name() {
  std::string* _s = _internal_mutable_addon_name();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_ServerInfo.addon_name)
  return _s;
}
inline const std::string& CSVCMsg_ServerInfo::_internal_addon_name() const {
  return _impl_.addon_name_.Get();
}
inline void CSVCMsg_ServerInfo::_internal_set_addon_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.addon_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_ServerInfo::_internal_mutable_addon_name() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.addon_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_ServerInfo::release_addon_name() {
  // @@protoc_insertion_point(field_release:CSVCMsg_ServerInfo.addon_name)
  if (!_internal_has_addon_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.addon_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.addon_name_.IsDefault()) {
    _impl_.addon_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_ServerInfo::set_allocated_addon_name(std::string* addon_name) {
  if (addon_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.addon_name_.SetAllocated(addon_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.addon_name_.IsDefault()) {
    _impl_.addon_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_ServerInfo.addon_name)
}

// optional .CSVCMsg_GameSessionConfiguration game_session_config = 19;
inline bool CSVCMsg_ServerInfo::_internal_has_game_session_config() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.game_session_config_ != nullptr);
  return value;
}
inline bool CSVCMsg_ServerInfo::has_game_session_config() const {
  return _internal_has_game_session_config();
}
inline const ::CSVCMsg_GameSessionConfiguration& CSVCMsg_ServerInfo::_internal_game_session_config() const {
  const ::CSVCMsg_GameSessionConfiguration* p = _impl_.game_session_config_;
  return p != nullptr ? *p : reinterpret_cast<const ::CSVCMsg_GameSessionConfiguration&>(
      ::_CSVCMsg_GameSessionConfiguration_default_instance_);
}
inline const ::CSVCMsg_GameSessionConfiguration& CSVCMsg_ServerInfo::game_session_config() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.game_session_config)
  return _internal_game_session_config();
}
inline void CSVCMsg_ServerInfo::unsafe_arena_set_allocated_game_session_config(
    ::CSVCMsg_GameSessionConfiguration* game_session_config) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.game_session_config_);
  }
  _impl_.game_session_config_ = game_session_config;
  if (game_session_config) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CSVCMsg_ServerInfo.game_session_config)
}
inline ::CSVCMsg_GameSessionConfiguration* CSVCMsg_ServerInfo::release_game_session_config() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::CSVCMsg_GameSessionConfiguration* temp = _impl_.game_session_config_;
  _impl_.game_session_config_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CSVCMsg_GameSessionConfiguration* CSVCMsg_ServerInfo::unsafe_arena_release_game_session_config() {
  // @@protoc_insertion_point(field_release:CSVCMsg_ServerInfo.game_session_config)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::CSVCMsg_GameSessionConfiguration* temp = _impl_.game_session_config_;
  _impl_.game_session_config_ = nullptr;
  return temp;
}
inline ::CSVCMsg_GameSessionConfiguration* CSVCMsg_ServerInfo::_internal_mutable_game_session_config() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.game_session_config_ == nullptr) {
    auto* p = CreateMaybeMessage<::CSVCMsg_GameSessionConfiguration>(GetArenaForAllocation());
    _impl_.game_session_config_ = p;
  }
  return _impl_.game_session_config_;
}
inline ::CSVCMsg_GameSessionConfiguration* CSVCMsg_ServerInfo::mutable_game_session_config() {
  ::CSVCMsg_GameSessionConfiguration* _msg = _internal_mutable_game_session_config();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_ServerInfo.game_session_config)
  return _msg;
}
inline void CSVCMsg_ServerInfo::set_allocated_game_session_config(::CSVCMsg_GameSessionConfiguration* game_session_config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.game_session_config_);
  }
  if (game_session_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(game_session_config));
    if (message_arena != submessage_arena) {
      game_session_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, game_session_config, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.game_session_config_ = game_session_config;
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_ServerInfo.game_session_config)
}

// optional bytes game_session_manifest = 20;
inline bool CSVCMsg_ServerInfo::_internal_has_game_session_manifest() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CSVCMsg_ServerInfo::has_game_session_manifest() const {
  return _internal_has_game_session_manifest();
}
inline void CSVCMsg_ServerInfo::clear_game_session_manifest() {
  _impl_.game_session_manifest_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& CSVCMsg_ServerInfo::game_session_manifest() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerInfo.game_session_manifest)
  return _internal_game_session_manifest();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_ServerInfo::set_game_session_manifest(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.game_session_manifest_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerInfo.game_session_manifest)
}
inline std::string* CSVCMsg_ServerInfo::mutable_game_session_manifest() {
  std::string* _s = _internal_mutable_game_session_manifest();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_ServerInfo.game_session_manifest)
  return _s;
}
inline const std::string& CSVCMsg_ServerInfo::_internal_game_session_manifest() const {
  return _impl_.game_session_manifest_.Get();
}
inline void CSVCMsg_ServerInfo::_internal_set_game_session_manifest(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.game_session_manifest_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_ServerInfo::_internal_mutable_game_session_manifest() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.game_session_manifest_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_ServerInfo::release_game_session_manifest() {
  // @@protoc_insertion_point(field_release:CSVCMsg_ServerInfo.game_session_manifest)
  if (!_internal_has_game_session_manifest()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.game_session_manifest_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.game_session_manifest_.IsDefault()) {
    _impl_.game_session_manifest_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_ServerInfo::set_allocated_game_session_manifest(std::string* game_session_manifest) {
  if (game_session_manifest != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.game_session_manifest_.SetAllocated(game_session_manifest, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.game_session_manifest_.IsDefault()) {
    _impl_.game_session_manifest_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_ServerInfo.game_session_manifest)
}

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

// CSVCMsg_ClassInfo_class_t

// optional int32 class_id = 1;
inline bool CSVCMsg_ClassInfo_class_t::_internal_has_class_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_ClassInfo_class_t::has_class_id() const {
  return _internal_has_class_id();
}
inline void CSVCMsg_ClassInfo_class_t::clear_class_id() {
  _impl_.class_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_ClassInfo_class_t::_internal_class_id() const {
  return _impl_.class_id_;
}
inline int32_t CSVCMsg_ClassInfo_class_t::class_id() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ClassInfo.class_t.class_id)
  return _internal_class_id();
}
inline void CSVCMsg_ClassInfo_class_t::_internal_set_class_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.class_id_ = value;
}
inline void CSVCMsg_ClassInfo_class_t::set_class_id(int32_t value) {
  _internal_set_class_id(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_ClassInfo.class_t.class_id)
}

// optional string class_name = 3;
inline bool CSVCMsg_ClassInfo_class_t::_internal_has_class_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_ClassInfo_class_t::has_class_name() const {
  return _internal_has_class_name();
}
inline void CSVCMsg_ClassInfo_class_t::clear_class_name() {
  _impl_.class_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_ClassInfo_class_t::class_name() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ClassInfo.class_t.class_name)
  return _internal_class_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_ClassInfo_class_t::set_class_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.class_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_ClassInfo.class_t.class_name)
}
inline std::string* CSVCMsg_ClassInfo_class_t::mutable_class_name() {
  std::string* _s = _internal_mutable_class_name();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_ClassInfo.class_t.class_name)
  return _s;
}
inline const std::string& CSVCMsg_ClassInfo_class_t::_internal_class_name() const {
  return _impl_.class_name_.Get();
}
inline void CSVCMsg_ClassInfo_class_t::_internal_set_class_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.class_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_ClassInfo_class_t::_internal_mutable_class_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.class_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_ClassInfo_class_t::release_class_name() {
  // @@protoc_insertion_point(field_release:CSVCMsg_ClassInfo.class_t.class_name)
  if (!_internal_has_class_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.class_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.class_name_.IsDefault()) {
    _impl_.class_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_ClassInfo_class_t::set_allocated_class_name(std::string* class_name) {
  if (class_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.class_name_.SetAllocated(class_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.class_name_.IsDefault()) {
    _impl_.class_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_ClassInfo.class_t.class_name)
}

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

// CSVCMsg_ClassInfo

// optional bool create_on_client = 1;
inline bool CSVCMsg_ClassInfo::_internal_has_create_on_client() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_ClassInfo::has_create_on_client() const {
  return _internal_has_create_on_client();
}
inline void CSVCMsg_ClassInfo::clear_create_on_client() {
  _impl_.create_on_client_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CSVCMsg_ClassInfo::_internal_create_on_client() const {
  return _impl_.create_on_client_;
}
inline bool CSVCMsg_ClassInfo::create_on_client() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ClassInfo.create_on_client)
  return _internal_create_on_client();
}
inline void CSVCMsg_ClassInfo::_internal_set_create_on_client(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.create_on_client_ = value;
}
inline void CSVCMsg_ClassInfo::set_create_on_client(bool value) {
  _internal_set_create_on_client(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_ClassInfo.create_on_client)
}

// repeated .CSVCMsg_ClassInfo.class_t classes = 2;
inline int CSVCMsg_ClassInfo::_internal_classes_size() const {
  return _impl_.classes_.size();
}
inline int CSVCMsg_ClassInfo::classes_size() const {
  return _internal_classes_size();
}
inline void CSVCMsg_ClassInfo::clear_classes() {
  _impl_.classes_.Clear();
}
inline ::CSVCMsg_ClassInfo_class_t* CSVCMsg_ClassInfo::mutable_classes(int index) {
  // @@protoc_insertion_point(field_mutable:CSVCMsg_ClassInfo.classes)
  return _impl_.classes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_ClassInfo_class_t >*
CSVCMsg_ClassInfo::mutable_classes() {
  // @@protoc_insertion_point(field_mutable_list:CSVCMsg_ClassInfo.classes)
  return &_impl_.classes_;
}
inline const ::CSVCMsg_ClassInfo_class_t& CSVCMsg_ClassInfo::_internal_classes(int index) const {
  return _impl_.classes_.Get(index);
}
inline const ::CSVCMsg_ClassInfo_class_t& CSVCMsg_ClassInfo::classes(int index) const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ClassInfo.classes)
  return _internal_classes(index);
}
inline ::CSVCMsg_ClassInfo_class_t* CSVCMsg_ClassInfo::_internal_add_classes() {
  return _impl_.classes_.Add();
}
inline ::CSVCMsg_ClassInfo_class_t* CSVCMsg_ClassInfo::add_classes() {
  ::CSVCMsg_ClassInfo_class_t* _add = _internal_add_classes();
  // @@protoc_insertion_point(field_add:CSVCMsg_ClassInfo.classes)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_ClassInfo_class_t >&
CSVCMsg_ClassInfo::classes() const {
  // @@protoc_insertion_point(field_list:CSVCMsg_ClassInfo.classes)
  return _impl_.classes_;
}

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

// CSVCMsg_SetPause

// optional bool paused = 1;
inline bool CSVCMsg_SetPause::_internal_has_paused() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_SetPause::has_paused() const {
  return _internal_has_paused();
}
inline void CSVCMsg_SetPause::clear_paused() {
  _impl_.paused_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CSVCMsg_SetPause::_internal_paused() const {
  return _impl_.paused_;
}
inline bool CSVCMsg_SetPause::paused() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SetPause.paused)
  return _internal_paused();
}
inline void CSVCMsg_SetPause::_internal_set_paused(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.paused_ = value;
}
inline void CSVCMsg_SetPause::set_paused(bool value) {
  _internal_set_paused(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_SetPause.paused)
}

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

// CSVCMsg_VoiceInit

// optional int32 quality = 1;
inline bool CSVCMsg_VoiceInit::_internal_has_quality() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_VoiceInit::has_quality() const {
  return _internal_has_quality();
}
inline void CSVCMsg_VoiceInit::clear_quality() {
  _impl_.quality_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_VoiceInit::_internal_quality() const {
  return _impl_.quality_;
}
inline int32_t CSVCMsg_VoiceInit::quality() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_VoiceInit.quality)
  return _internal_quality();
}
inline void CSVCMsg_VoiceInit::_internal_set_quality(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.quality_ = value;
}
inline void CSVCMsg_VoiceInit::set_quality(int32_t value) {
  _internal_set_quality(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_VoiceInit.quality)
}

// optional string codec = 2;
inline bool CSVCMsg_VoiceInit::_internal_has_codec() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_VoiceInit::has_codec() const {
  return _internal_has_codec();
}
inline void CSVCMsg_VoiceInit::clear_codec() {
  _impl_.codec_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_VoiceInit::codec() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_VoiceInit.codec)
  return _internal_codec();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_VoiceInit::set_codec(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.codec_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_VoiceInit.codec)
}
inline std::string* CSVCMsg_VoiceInit::mutable_codec() {
  std::string* _s = _internal_mutable_codec();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_VoiceInit.codec)
  return _s;
}
inline const std::string& CSVCMsg_VoiceInit::_internal_codec() const {
  return _impl_.codec_.Get();
}
inline void CSVCMsg_VoiceInit::_internal_set_codec(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.codec_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_VoiceInit::_internal_mutable_codec() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.codec_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_VoiceInit::release_codec() {
  // @@protoc_insertion_point(field_release:CSVCMsg_VoiceInit.codec)
  if (!_internal_has_codec()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.codec_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.codec_.IsDefault()) {
    _impl_.codec_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_VoiceInit::set_allocated_codec(std::string* codec) {
  if (codec != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.codec_.SetAllocated(codec, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.codec_.IsDefault()) {
    _impl_.codec_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_VoiceInit.codec)
}

// optional int32 version = 3 [default = 0];
inline bool CSVCMsg_VoiceInit::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_VoiceInit::has_version() const {
  return _internal_has_version();
}
inline void CSVCMsg_VoiceInit::clear_version() {
  _impl_.version_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CSVCMsg_VoiceInit::_internal_version() const {
  return _impl_.version_;
}
inline int32_t CSVCMsg_VoiceInit::version() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_VoiceInit.version)
  return _internal_version();
}
inline void CSVCMsg_VoiceInit::_internal_set_version(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.version_ = value;
}
inline void CSVCMsg_VoiceInit::set_version(int32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_VoiceInit.version)
}

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

// CSVCMsg_Print

// optional string text = 1;
inline bool CSVCMsg_Print::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_Print::has_text() const {
  return _internal_has_text();
}
inline void CSVCMsg_Print::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_Print::text() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Print.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_Print::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_Print.text)
}
inline std::string* CSVCMsg_Print::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_Print.text)
  return _s;
}
inline const std::string& CSVCMsg_Print::_internal_text() const {
  return _impl_.text_.Get();
}
inline void CSVCMsg_Print::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_Print::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_Print::release_text() {
  // @@protoc_insertion_point(field_release:CSVCMsg_Print.text)
  if (!_internal_has_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.text_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_Print::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_Print.text)
}

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

// CSVCMsg_Sounds_sounddata_t

// optional sint32 origin_x = 1;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_origin_x() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_origin_x() const {
  return _internal_has_origin_x();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_origin_x() {
  _impl_.origin_x_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::_internal_origin_x() const {
  return _impl_.origin_x_;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::origin_x() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.origin_x)
  return _internal_origin_x();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_origin_x(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.origin_x_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_origin_x(int32_t value) {
  _internal_set_origin_x(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.origin_x)
}

// optional sint32 origin_y = 2;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_origin_y() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_origin_y() const {
  return _internal_has_origin_y();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_origin_y() {
  _impl_.origin_y_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::_internal_origin_y() const {
  return _impl_.origin_y_;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::origin_y() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.origin_y)
  return _internal_origin_y();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_origin_y(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.origin_y_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_origin_y(int32_t value) {
  _internal_set_origin_y(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.origin_y)
}

// optional sint32 origin_z = 3;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_origin_z() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_origin_z() const {
  return _internal_has_origin_z();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_origin_z() {
  _impl_.origin_z_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::_internal_origin_z() const {
  return _impl_.origin_z_;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::origin_z() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.origin_z)
  return _internal_origin_z();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_origin_z(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.origin_z_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_origin_z(int32_t value) {
  _internal_set_origin_z(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.origin_z)
}

// optional uint32 volume = 4;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_volume() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_volume() const {
  return _internal_has_volume();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_volume() {
  _impl_.volume_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CSVCMsg_Sounds_sounddata_t::_internal_volume() const {
  return _impl_.volume_;
}
inline uint32_t CSVCMsg_Sounds_sounddata_t::volume() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.volume)
  return _internal_volume();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_volume(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.volume_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_volume(uint32_t value) {
  _internal_set_volume(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.volume)
}

// optional float delay_value = 5;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_delay_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_delay_value() const {
  return _internal_has_delay_value();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_delay_value() {
  _impl_.delay_value_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float CSVCMsg_Sounds_sounddata_t::_internal_delay_value() const {
  return _impl_.delay_value_;
}
inline float CSVCMsg_Sounds_sounddata_t::delay_value() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.delay_value)
  return _internal_delay_value();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_delay_value(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.delay_value_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_delay_value(float value) {
  _internal_set_delay_value(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.delay_value)
}

// optional int32 sequence_number = 6;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_sequence_number() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_sequence_number() const {
  return _internal_has_sequence_number();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_sequence_number() {
  _impl_.sequence_number_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::_internal_sequence_number() const {
  return _impl_.sequence_number_;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::sequence_number() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.sequence_number)
  return _internal_sequence_number();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_sequence_number(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.sequence_number_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_sequence_number(int32_t value) {
  _internal_set_sequence_number(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.sequence_number)
}

// optional int32 entity_index = 7 [default = -1];
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_entity_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_entity_index() const {
  return _internal_has_entity_index();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_entity_index() {
  _impl_.entity_index_ = -1;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::_internal_entity_index() const {
  return _impl_.entity_index_;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::entity_index() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.entity_index)
  return _internal_entity_index();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_entity_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.entity_index_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_entity_index(int32_t value) {
  _internal_set_entity_index(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.entity_index)
}

// optional int32 channel = 8;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_channel() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_channel() const {
  return _internal_has_channel();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_channel() {
  _impl_.channel_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::_internal_channel() const {
  return _impl_.channel_;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::channel() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.channel)
  return _internal_channel();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_channel(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.channel_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_channel(int32_t value) {
  _internal_set_channel(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.channel)
}

// optional int32 pitch = 9;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_pitch() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_pitch() const {
  return _internal_has_pitch();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_pitch() {
  _impl_.pitch_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::_internal_pitch() const {
  return _impl_.pitch_;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::pitch() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.pitch)
  return _internal_pitch();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_pitch(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.pitch_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_pitch(int32_t value) {
  _internal_set_pitch(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.pitch)
}

// optional int32 flags = 10;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_flags() const {
  return _internal_has_flags();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_flags() {
  _impl_.flags_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::_internal_flags() const {
  return _impl_.flags_;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::flags() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.flags)
  return _internal_flags();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_flags(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.flags_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_flags(int32_t value) {
  _internal_set_flags(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.flags)
}

// optional uint32 sound_num = 11;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_sound_num() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_sound_num() const {
  return _internal_has_sound_num();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_sound_num() {
  _impl_.sound_num_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t CSVCMsg_Sounds_sounddata_t::_internal_sound_num() const {
  return _impl_.sound_num_;
}
inline uint32_t CSVCMsg_Sounds_sounddata_t::sound_num() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.sound_num)
  return _internal_sound_num();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_sound_num(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.sound_num_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_sound_num(uint32_t value) {
  _internal_set_sound_num(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.sound_num)
}

// optional fixed32 sound_num_handle = 12;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_sound_num_handle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_sound_num_handle() const {
  return _internal_has_sound_num_handle();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_sound_num_handle() {
  _impl_.sound_num_handle_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CSVCMsg_Sounds_sounddata_t::_internal_sound_num_handle() const {
  return _impl_.sound_num_handle_;
}
inline uint32_t CSVCMsg_Sounds_sounddata_t::sound_num_handle() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.sound_num_handle)
  return _internal_sound_num_handle();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_sound_num_handle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.sound_num_handle_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_sound_num_handle(uint32_t value) {
  _internal_set_sound_num_handle(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.sound_num_handle)
}

// optional int32 speaker_entity = 13;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_speaker_entity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_speaker_entity() const {
  return _internal_has_speaker_entity();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_speaker_entity() {
  _impl_.speaker_entity_ = 0;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::_internal_speaker_entity() const {
  return _impl_.speaker_entity_;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::speaker_entity() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.speaker_entity)
  return _internal_speaker_entity();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_speaker_entity(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.speaker_entity_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_speaker_entity(int32_t value) {
  _internal_set_speaker_entity(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.speaker_entity)
}

// optional int32 random_seed = 14;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_random_seed() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_random_seed() const {
  return _internal_has_random_seed();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_random_seed() {
  _impl_.random_seed_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::_internal_random_seed() const {
  return _impl_.random_seed_;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::random_seed() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.random_seed)
  return _internal_random_seed();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_random_seed(int32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.random_seed_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_random_seed(int32_t value) {
  _internal_set_random_seed(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.random_seed)
}

// optional int32 sound_level = 15;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_sound_level() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_sound_level() const {
  return _internal_has_sound_level();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_sound_level() {
  _impl_.sound_level_ = 0;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::_internal_sound_level() const {
  return _impl_.sound_level_;
}
inline int32_t CSVCMsg_Sounds_sounddata_t::sound_level() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.sound_level)
  return _internal_sound_level();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_sound_level(int32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.sound_level_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_sound_level(int32_t value) {
  _internal_set_sound_level(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.sound_level)
}

// optional bool is_sentence = 16;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_is_sentence() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_is_sentence() const {
  return _internal_has_is_sentence();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_is_sentence() {
  _impl_.is_sentence_ = false;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline bool CSVCMsg_Sounds_sounddata_t::_internal_is_sentence() const {
  return _impl_.is_sentence_;
}
inline bool CSVCMsg_Sounds_sounddata_t::is_sentence() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.is_sentence)
  return _internal_is_sentence();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_is_sentence(bool value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.is_sentence_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_is_sentence(bool value) {
  _internal_set_is_sentence(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.is_sentence)
}

// optional bool is_ambient = 17;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_is_ambient() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_is_ambient() const {
  return _internal_has_is_ambient();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_is_ambient() {
  _impl_.is_ambient_ = false;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline bool CSVCMsg_Sounds_sounddata_t::_internal_is_ambient() const {
  return _impl_.is_ambient_;
}
inline bool CSVCMsg_Sounds_sounddata_t::is_ambient() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.is_ambient)
  return _internal_is_ambient();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_is_ambient(bool value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.is_ambient_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_is_ambient(bool value) {
  _internal_set_is_ambient(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.is_ambient)
}

// optional uint32 guid = 18;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_guid() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_guid() const {
  return _internal_has_guid();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_guid() {
  _impl_.guid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline uint32_t CSVCMsg_Sounds_sounddata_t::_internal_guid() const {
  return _impl_.guid_;
}
inline uint32_t CSVCMsg_Sounds_sounddata_t::guid() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.guid)
  return _internal_guid();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_guid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.guid_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_guid(uint32_t value) {
  _internal_set_guid(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.guid)
}

// optional fixed64 sound_resource_id = 19;
inline bool CSVCMsg_Sounds_sounddata_t::_internal_has_sound_resource_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds_sounddata_t::has_sound_resource_id() const {
  return _internal_has_sound_resource_id();
}
inline void CSVCMsg_Sounds_sounddata_t::clear_sound_resource_id() {
  _impl_.sound_resource_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline uint64_t CSVCMsg_Sounds_sounddata_t::_internal_sound_resource_id() const {
  return _impl_.sound_resource_id_;
}
inline uint64_t CSVCMsg_Sounds_sounddata_t::sound_resource_id() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounddata_t.sound_resource_id)
  return _internal_sound_resource_id();
}
inline void CSVCMsg_Sounds_sounddata_t::_internal_set_sound_resource_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.sound_resource_id_ = value;
}
inline void CSVCMsg_Sounds_sounddata_t::set_sound_resource_id(uint64_t value) {
  _internal_set_sound_resource_id(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.sounddata_t.sound_resource_id)
}

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

// CSVCMsg_Sounds

// optional bool reliable_sound = 1;
inline bool CSVCMsg_Sounds::_internal_has_reliable_sound() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_Sounds::has_reliable_sound() const {
  return _internal_has_reliable_sound();
}
inline void CSVCMsg_Sounds::clear_reliable_sound() {
  _impl_.reliable_sound_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CSVCMsg_Sounds::_internal_reliable_sound() const {
  return _impl_.reliable_sound_;
}
inline bool CSVCMsg_Sounds::reliable_sound() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.reliable_sound)
  return _internal_reliable_sound();
}
inline void CSVCMsg_Sounds::_internal_set_reliable_sound(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.reliable_sound_ = value;
}
inline void CSVCMsg_Sounds::set_reliable_sound(bool value) {
  _internal_set_reliable_sound(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Sounds.reliable_sound)
}

// repeated .CSVCMsg_Sounds.sounddata_t sounds = 2;
inline int CSVCMsg_Sounds::_internal_sounds_size() const {
  return _impl_.sounds_.size();
}
inline int CSVCMsg_Sounds::sounds_size() const {
  return _internal_sounds_size();
}
inline void CSVCMsg_Sounds::clear_sounds() {
  _impl_.sounds_.Clear();
}
inline ::CSVCMsg_Sounds_sounddata_t* CSVCMsg_Sounds::mutable_sounds(int index) {
  // @@protoc_insertion_point(field_mutable:CSVCMsg_Sounds.sounds)
  return _impl_.sounds_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_Sounds_sounddata_t >*
CSVCMsg_Sounds::mutable_sounds() {
  // @@protoc_insertion_point(field_mutable_list:CSVCMsg_Sounds.sounds)
  return &_impl_.sounds_;
}
inline const ::CSVCMsg_Sounds_sounddata_t& CSVCMsg_Sounds::_internal_sounds(int index) const {
  return _impl_.sounds_.Get(index);
}
inline const ::CSVCMsg_Sounds_sounddata_t& CSVCMsg_Sounds::sounds(int index) const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Sounds.sounds)
  return _internal_sounds(index);
}
inline ::CSVCMsg_Sounds_sounddata_t* CSVCMsg_Sounds::_internal_add_sounds() {
  return _impl_.sounds_.Add();
}
inline ::CSVCMsg_Sounds_sounddata_t* CSVCMsg_Sounds::add_sounds() {
  ::CSVCMsg_Sounds_sounddata_t* _add = _internal_add_sounds();
  // @@protoc_insertion_point(field_add:CSVCMsg_Sounds.sounds)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_Sounds_sounddata_t >&
CSVCMsg_Sounds::sounds() const {
  // @@protoc_insertion_point(field_list:CSVCMsg_Sounds.sounds)
  return _impl_.sounds_;
}

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

// CSVCMsg_Prefetch

// optional int32 sound_index = 1;
inline bool CSVCMsg_Prefetch::_internal_has_sound_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_Prefetch::has_sound_index() const {
  return _internal_has_sound_index();
}
inline void CSVCMsg_Prefetch::clear_sound_index() {
  _impl_.sound_index_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CSVCMsg_Prefetch::_internal_sound_index() const {
  return _impl_.sound_index_;
}
inline int32_t CSVCMsg_Prefetch::sound_index() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Prefetch.sound_index)
  return _internal_sound_index();
}
inline void CSVCMsg_Prefetch::_internal_set_sound_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.sound_index_ = value;
}
inline void CSVCMsg_Prefetch::set_sound_index(int32_t value) {
  _internal_set_sound_index(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Prefetch.sound_index)
}

// optional .PrefetchType resource_type = 2 [default = PFT_SOUND];
inline bool CSVCMsg_Prefetch::_internal_has_resource_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_Prefetch::has_resource_type() const {
  return _internal_has_resource_type();
}
inline void CSVCMsg_Prefetch::clear_resource_type() {
  _impl_.resource_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::PrefetchType CSVCMsg_Prefetch::_internal_resource_type() const {
  return static_cast< ::PrefetchType >(_impl_.resource_type_);
}
inline ::PrefetchType CSVCMsg_Prefetch::resource_type() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Prefetch.resource_type)
  return _internal_resource_type();
}
inline void CSVCMsg_Prefetch::_internal_set_resource_type(::PrefetchType value) {
  assert(::PrefetchType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.resource_type_ = value;
}
inline void CSVCMsg_Prefetch::set_resource_type(::PrefetchType value) {
  _internal_set_resource_type(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Prefetch.resource_type)
}

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

// CSVCMsg_SetView

// optional int32 entity_index = 1 [default = -1];
inline bool CSVCMsg_SetView::_internal_has_entity_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_SetView::has_entity_index() const {
  return _internal_has_entity_index();
}
inline void CSVCMsg_SetView::clear_entity_index() {
  _impl_.entity_index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CSVCMsg_SetView::_internal_entity_index() const {
  return _impl_.entity_index_;
}
inline int32_t CSVCMsg_SetView::entity_index() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SetView.entity_index)
  return _internal_entity_index();
}
inline void CSVCMsg_SetView::_internal_set_entity_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.entity_index_ = value;
}
inline void CSVCMsg_SetView::set_entity_index(int32_t value) {
  _internal_set_entity_index(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_SetView.entity_index)
}

// optional int32 slot = 2 [default = -1];
inline bool CSVCMsg_SetView::_internal_has_slot() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_SetView::has_slot() const {
  return _internal_has_slot();
}
inline void CSVCMsg_SetView::clear_slot() {
  _impl_.slot_ = -1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_SetView::_internal_slot() const {
  return _impl_.slot_;
}
inline int32_t CSVCMsg_SetView::slot() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SetView.slot)
  return _internal_slot();
}
inline void CSVCMsg_SetView::_internal_set_slot(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.slot_ = value;
}
inline void CSVCMsg_SetView::set_slot(int32_t value) {
  _internal_set_slot(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_SetView.slot)
}

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

// CSVCMsg_FixAngle

// optional bool relative = 1;
inline bool CSVCMsg_FixAngle::_internal_has_relative() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_FixAngle::has_relative() const {
  return _internal_has_relative();
}
inline void CSVCMsg_FixAngle::clear_relative() {
  _impl_.relative_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CSVCMsg_FixAngle::_internal_relative() const {
  return _impl_.relative_;
}
inline bool CSVCMsg_FixAngle::relative() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_FixAngle.relative)
  return _internal_relative();
}
inline void CSVCMsg_FixAngle::_internal_set_relative(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.relative_ = value;
}
inline void CSVCMsg_FixAngle::set_relative(bool value) {
  _internal_set_relative(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_FixAngle.relative)
}

// optional .CMsgQAngle angle = 2;
inline bool CSVCMsg_FixAngle::_internal_has_angle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.angle_ != nullptr);
  return value;
}
inline bool CSVCMsg_FixAngle::has_angle() const {
  return _internal_has_angle();
}
inline const ::CMsgQAngle& CSVCMsg_FixAngle::_internal_angle() const {
  const ::CMsgQAngle* p = _impl_.angle_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQAngle&>(
      ::_CMsgQAngle_default_instance_);
}
inline const ::CMsgQAngle& CSVCMsg_FixAngle::angle() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_FixAngle.angle)
  return _internal_angle();
}
inline void CSVCMsg_FixAngle::unsafe_arena_set_allocated_angle(
    ::CMsgQAngle* angle) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angle_);
  }
  _impl_.angle_ = angle;
  if (angle) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CSVCMsg_FixAngle.angle)
}
inline ::CMsgQAngle* CSVCMsg_FixAngle::release_angle() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgQAngle* temp = _impl_.angle_;
  _impl_.angle_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgQAngle* CSVCMsg_FixAngle::unsafe_arena_release_angle() {
  // @@protoc_insertion_point(field_release:CSVCMsg_FixAngle.angle)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgQAngle* temp = _impl_.angle_;
  _impl_.angle_ = nullptr;
  return temp;
}
inline ::CMsgQAngle* CSVCMsg_FixAngle::_internal_mutable_angle() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.angle_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgQAngle>(GetArenaForAllocation());
    _impl_.angle_ = p;
  }
  return _impl_.angle_;
}
inline ::CMsgQAngle* CSVCMsg_FixAngle::mutable_angle() {
  ::CMsgQAngle* _msg = _internal_mutable_angle();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_FixAngle.angle)
  return _msg;
}
inline void CSVCMsg_FixAngle::set_allocated_angle(::CMsgQAngle* angle) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angle_);
  }
  if (angle) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(angle));
    if (message_arena != submessage_arena) {
      angle = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, angle, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.angle_ = angle;
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_FixAngle.angle)
}

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

// CSVCMsg_CrosshairAngle

// optional .CMsgQAngle angle = 1;
inline bool CSVCMsg_CrosshairAngle::_internal_has_angle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.angle_ != nullptr);
  return value;
}
inline bool CSVCMsg_CrosshairAngle::has_angle() const {
  return _internal_has_angle();
}
inline const ::CMsgQAngle& CSVCMsg_CrosshairAngle::_internal_angle() const {
  const ::CMsgQAngle* p = _impl_.angle_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQAngle&>(
      ::_CMsgQAngle_default_instance_);
}
inline const ::CMsgQAngle& CSVCMsg_CrosshairAngle::angle() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_CrosshairAngle.angle)
  return _internal_angle();
}
inline void CSVCMsg_CrosshairAngle::unsafe_arena_set_allocated_angle(
    ::CMsgQAngle* angle) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angle_);
  }
  _impl_.angle_ = angle;
  if (angle) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CSVCMsg_CrosshairAngle.angle)
}
inline ::CMsgQAngle* CSVCMsg_CrosshairAngle::release_angle() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgQAngle* temp = _impl_.angle_;
  _impl_.angle_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgQAngle* CSVCMsg_CrosshairAngle::unsafe_arena_release_angle() {
  // @@protoc_insertion_point(field_release:CSVCMsg_CrosshairAngle.angle)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgQAngle* temp = _impl_.angle_;
  _impl_.angle_ = nullptr;
  return temp;
}
inline ::CMsgQAngle* CSVCMsg_CrosshairAngle::_internal_mutable_angle() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.angle_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgQAngle>(GetArenaForAllocation());
    _impl_.angle_ = p;
  }
  return _impl_.angle_;
}
inline ::CMsgQAngle* CSVCMsg_CrosshairAngle::mutable_angle() {
  ::CMsgQAngle* _msg = _internal_mutable_angle();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_CrosshairAngle.angle)
  return _msg;
}
inline void CSVCMsg_CrosshairAngle::set_allocated_angle(::CMsgQAngle* angle) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angle_);
  }
  if (angle) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(angle));
    if (message_arena != submessage_arena) {
      angle = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, angle, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.angle_ = angle;
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_CrosshairAngle.angle)
}

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

// CSVCMsg_BSPDecal

// optional .CMsgVector pos = 1;
inline bool CSVCMsg_BSPDecal::_internal_has_pos() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pos_ != nullptr);
  return value;
}
inline bool CSVCMsg_BSPDecal::has_pos() const {
  return _internal_has_pos();
}
inline const ::CMsgVector& CSVCMsg_BSPDecal::_internal_pos() const {
  const ::CMsgVector* p = _impl_.pos_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CSVCMsg_BSPDecal::pos() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_BSPDecal.pos)
  return _internal_pos();
}
inline void CSVCMsg_BSPDecal::unsafe_arena_set_allocated_pos(
    ::CMsgVector* pos) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pos_);
  }
  _impl_.pos_ = pos;
  if (pos) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CSVCMsg_BSPDecal.pos)
}
inline ::CMsgVector* CSVCMsg_BSPDecal::release_pos() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.pos_;
  _impl_.pos_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CSVCMsg_BSPDecal::unsafe_arena_release_pos() {
  // @@protoc_insertion_point(field_release:CSVCMsg_BSPDecal.pos)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.pos_;
  _impl_.pos_ = nullptr;
  return temp;
}
inline ::CMsgVector* CSVCMsg_BSPDecal::_internal_mutable_pos() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.pos_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.pos_ = p;
  }
  return _impl_.pos_;
}
inline ::CMsgVector* CSVCMsg_BSPDecal::mutable_pos() {
  ::CMsgVector* _msg = _internal_mutable_pos();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_BSPDecal.pos)
  return _msg;
}
inline void CSVCMsg_BSPDecal::set_allocated_pos(::CMsgVector* pos) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pos_);
  }
  if (pos) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(pos));
    if (message_arena != submessage_arena) {
      pos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pos, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.pos_ = pos;
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_BSPDecal.pos)
}

// optional int32 decal_texture_index = 2;
inline bool CSVCMsg_BSPDecal::_internal_has_decal_texture_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_BSPDecal::has_decal_texture_index() const {
  return _internal_has_decal_texture_index();
}
inline void CSVCMsg_BSPDecal::clear_decal_texture_index() {
  _impl_.decal_texture_index_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_BSPDecal::_internal_decal_texture_index() const {
  return _impl_.decal_texture_index_;
}
inline int32_t CSVCMsg_BSPDecal::decal_texture_index() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_BSPDecal.decal_texture_index)
  return _internal_decal_texture_index();
}
inline void CSVCMsg_BSPDecal::_internal_set_decal_texture_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.decal_texture_index_ = value;
}
inline void CSVCMsg_BSPDecal::set_decal_texture_index(int32_t value) {
  _internal_set_decal_texture_index(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_BSPDecal.decal_texture_index)
}

// optional int32 entity_index = 3 [default = -1];
inline bool CSVCMsg_BSPDecal::_internal_has_entity_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSVCMsg_BSPDecal::has_entity_index() const {
  return _internal_has_entity_index();
}
inline void CSVCMsg_BSPDecal::clear_entity_index() {
  _impl_.entity_index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CSVCMsg_BSPDecal::_internal_entity_index() const {
  return _impl_.entity_index_;
}
inline int32_t CSVCMsg_BSPDecal::entity_index() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_BSPDecal.entity_index)
  return _internal_entity_index();
}
inline void CSVCMsg_BSPDecal::_internal_set_entity_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.entity_index_ = value;
}
inline void CSVCMsg_BSPDecal::set_entity_index(int32_t value) {
  _internal_set_entity_index(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_BSPDecal.entity_index)
}

// optional int32 model_index = 4;
inline bool CSVCMsg_BSPDecal::_internal_has_model_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_BSPDecal::has_model_index() const {
  return _internal_has_model_index();
}
inline void CSVCMsg_BSPDecal::clear_model_index() {
  _impl_.model_index_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CSVCMsg_BSPDecal::_internal_model_index() const {
  return _impl_.model_index_;
}
inline int32_t CSVCMsg_BSPDecal::model_index() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_BSPDecal.model_index)
  return _internal_model_index();
}
inline void CSVCMsg_BSPDecal::_internal_set_model_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.model_index_ = value;
}
inline void CSVCMsg_BSPDecal::set_model_index(int32_t value) {
  _internal_set_model_index(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_BSPDecal.model_index)
}

// optional bool low_priority = 5;
inline bool CSVCMsg_BSPDecal::_internal_has_low_priority() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSVCMsg_BSPDecal::has_low_priority() const {
  return _internal_has_low_priority();
}
inline void CSVCMsg_BSPDecal::clear_low_priority() {
  _impl_.low_priority_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool CSVCMsg_BSPDecal::_internal_low_priority() const {
  return _impl_.low_priority_;
}
inline bool CSVCMsg_BSPDecal::low_priority() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_BSPDecal.low_priority)
  return _internal_low_priority();
}
inline void CSVCMsg_BSPDecal::_internal_set_low_priority(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.low_priority_ = value;
}
inline void CSVCMsg_BSPDecal::set_low_priority(bool value) {
  _internal_set_low_priority(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_BSPDecal.low_priority)
}

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

// CSVCMsg_SplitScreen

// optional .ESplitScreenMessageType type = 1 [default = MSG_SPLITSCREEN_ADDUSER];
inline bool CSVCMsg_SplitScreen::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_SplitScreen::has_type() const {
  return _internal_has_type();
}
inline void CSVCMsg_SplitScreen::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::ESplitScreenMessageType CSVCMsg_SplitScreen::_internal_type() const {
  return static_cast< ::ESplitScreenMessageType >(_impl_.type_);
}
inline ::ESplitScreenMessageType CSVCMsg_SplitScreen::type() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SplitScreen.type)
  return _internal_type();
}
inline void CSVCMsg_SplitScreen::_internal_set_type(::ESplitScreenMessageType value) {
  assert(::ESplitScreenMessageType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.type_ = value;
}
inline void CSVCMsg_SplitScreen::set_type(::ESplitScreenMessageType value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_SplitScreen.type)
}

// optional int32 slot = 2;
inline bool CSVCMsg_SplitScreen::_internal_has_slot() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_SplitScreen::has_slot() const {
  return _internal_has_slot();
}
inline void CSVCMsg_SplitScreen::clear_slot() {
  _impl_.slot_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_SplitScreen::_internal_slot() const {
  return _impl_.slot_;
}
inline int32_t CSVCMsg_SplitScreen::slot() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SplitScreen.slot)
  return _internal_slot();
}
inline void CSVCMsg_SplitScreen::_internal_set_slot(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.slot_ = value;
}
inline void CSVCMsg_SplitScreen::set_slot(int32_t value) {
  _internal_set_slot(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_SplitScreen.slot)
}

// optional int32 player_index = 3 [default = -1];
inline bool CSVCMsg_SplitScreen::_internal_has_player_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_SplitScreen::has_player_index() const {
  return _internal_has_player_index();
}
inline void CSVCMsg_SplitScreen::clear_player_index() {
  _impl_.player_index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CSVCMsg_SplitScreen::_internal_player_index() const {
  return _impl_.player_index_;
}
inline int32_t CSVCMsg_SplitScreen::player_index() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SplitScreen.player_index)
  return _internal_player_index();
}
inline void CSVCMsg_SplitScreen::_internal_set_player_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.player_index_ = value;
}
inline void CSVCMsg_SplitScreen::set_player_index(int32_t value) {
  _internal_set_player_index(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_SplitScreen.player_index)
}

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

// CSVCMsg_GetCvarValue

// optional int32 cookie = 1;
inline bool CSVCMsg_GetCvarValue::_internal_has_cookie() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_GetCvarValue::has_cookie() const {
  return _internal_has_cookie();
}
inline void CSVCMsg_GetCvarValue::clear_cookie() {
  _impl_.cookie_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_GetCvarValue::_internal_cookie() const {
  return _impl_.cookie_;
}
inline int32_t CSVCMsg_GetCvarValue::cookie() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GetCvarValue.cookie)
  return _internal_cookie();
}
inline void CSVCMsg_GetCvarValue::_internal_set_cookie(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.cookie_ = value;
}
inline void CSVCMsg_GetCvarValue::set_cookie(int32_t value) {
  _internal_set_cookie(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GetCvarValue.cookie)
}

// optional string cvar_name = 2;
inline bool CSVCMsg_GetCvarValue::_internal_has_cvar_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_GetCvarValue::has_cvar_name() const {
  return _internal_has_cvar_name();
}
inline void CSVCMsg_GetCvarValue::clear_cvar_name() {
  _impl_.cvar_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_GetCvarValue::cvar_name() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GetCvarValue.cvar_name)
  return _internal_cvar_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_GetCvarValue::set_cvar_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.cvar_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_GetCvarValue.cvar_name)
}
inline std::string* CSVCMsg_GetCvarValue::mutable_cvar_name() {
  std::string* _s = _internal_mutable_cvar_name();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GetCvarValue.cvar_name)
  return _s;
}
inline const std::string& CSVCMsg_GetCvarValue::_internal_cvar_name() const {
  return _impl_.cvar_name_.Get();
}
inline void CSVCMsg_GetCvarValue::_internal_set_cvar_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.cvar_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_GetCvarValue::_internal_mutable_cvar_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.cvar_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_GetCvarValue::release_cvar_name() {
  // @@protoc_insertion_point(field_release:CSVCMsg_GetCvarValue.cvar_name)
  if (!_internal_has_cvar_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.cvar_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.cvar_name_.IsDefault()) {
    _impl_.cvar_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_GetCvarValue::set_allocated_cvar_name(std::string* cvar_name) {
  if (cvar_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.cvar_name_.SetAllocated(cvar_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.cvar_name_.IsDefault()) {
    _impl_.cvar_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_GetCvarValue.cvar_name)
}

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

// CSVCMsg_Menu

// optional int32 dialog_type = 1;
inline bool CSVCMsg_Menu::_internal_has_dialog_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_Menu::has_dialog_type() const {
  return _internal_has_dialog_type();
}
inline void CSVCMsg_Menu::clear_dialog_type() {
  _impl_.dialog_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_Menu::_internal_dialog_type() const {
  return _impl_.dialog_type_;
}
inline int32_t CSVCMsg_Menu::dialog_type() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Menu.dialog_type)
  return _internal_dialog_type();
}
inline void CSVCMsg_Menu::_internal_set_dialog_type(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.dialog_type_ = value;
}
inline void CSVCMsg_Menu::set_dialog_type(int32_t value) {
  _internal_set_dialog_type(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_Menu.dialog_type)
}

// optional bytes menu_key_values = 2;
inline bool CSVCMsg_Menu::_internal_has_menu_key_values() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_Menu::has_menu_key_values() const {
  return _internal_has_menu_key_values();
}
inline void CSVCMsg_Menu::clear_menu_key_values() {
  _impl_.menu_key_values_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_Menu::menu_key_values() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Menu.menu_key_values)
  return _internal_menu_key_values();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_Menu::set_menu_key_values(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.menu_key_values_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_Menu.menu_key_values)
}
inline std::string* CSVCMsg_Menu::mutable_menu_key_values() {
  std::string* _s = _internal_mutable_menu_key_values();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_Menu.menu_key_values)
  return _s;
}
inline const std::string& CSVCMsg_Menu::_internal_menu_key_values() const {
  return _impl_.menu_key_values_.Get();
}
inline void CSVCMsg_Menu::_internal_set_menu_key_values(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.menu_key_values_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_Menu::_internal_mutable_menu_key_values() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.menu_key_values_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_Menu::release_menu_key_values() {
  // @@protoc_insertion_point(field_release:CSVCMsg_Menu.menu_key_values)
  if (!_internal_has_menu_key_values()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.menu_key_values_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.menu_key_values_.IsDefault()) {
    _impl_.menu_key_values_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_Menu::set_allocated_menu_key_values(std::string* menu_key_values) {
  if (menu_key_values != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.menu_key_values_.SetAllocated(menu_key_values, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.menu_key_values_.IsDefault()) {
    _impl_.menu_key_values_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_Menu.menu_key_values)
}

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

// CSVCMsg_UserMessage

// optional int32 msg_type = 1;
inline bool CSVCMsg_UserMessage::_internal_has_msg_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_UserMessage::has_msg_type() const {
  return _internal_has_msg_type();
}
inline void CSVCMsg_UserMessage::clear_msg_type() {
  _impl_.msg_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_UserMessage::_internal_msg_type() const {
  return _impl_.msg_type_;
}
inline int32_t CSVCMsg_UserMessage::msg_type() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_UserMessage.msg_type)
  return _internal_msg_type();
}
inline void CSVCMsg_UserMessage::_internal_set_msg_type(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.msg_type_ = value;
}
inline void CSVCMsg_UserMessage::set_msg_type(int32_t value) {
  _internal_set_msg_type(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_UserMessage.msg_type)
}

// optional bytes msg_data = 2;
inline bool CSVCMsg_UserMessage::_internal_has_msg_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_UserMessage::has_msg_data() const {
  return _internal_has_msg_data();
}
inline void CSVCMsg_UserMessage::clear_msg_data() {
  _impl_.msg_data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_UserMessage::msg_data() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_UserMessage.msg_data)
  return _internal_msg_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_UserMessage::set_msg_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.msg_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_UserMessage.msg_data)
}
inline std::string* CSVCMsg_UserMessage::mutable_msg_data() {
  std::string* _s = _internal_mutable_msg_data();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_UserMessage.msg_data)
  return _s;
}
inline const std::string& CSVCMsg_UserMessage::_internal_msg_data() const {
  return _impl_.msg_data_.Get();
}
inline void CSVCMsg_UserMessage::_internal_set_msg_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.msg_data_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_UserMessage::_internal_mutable_msg_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.msg_data_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_UserMessage::release_msg_data() {
  // @@protoc_insertion_point(field_release:CSVCMsg_UserMessage.msg_data)
  if (!_internal_has_msg_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.msg_data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.msg_data_.IsDefault()) {
    _impl_.msg_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_UserMessage::set_allocated_msg_data(std::string* msg_data) {
  if (msg_data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.msg_data_.SetAllocated(msg_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.msg_data_.IsDefault()) {
    _impl_.msg_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_UserMessage.msg_data)
}

// optional int32 passthrough = 3;
inline bool CSVCMsg_UserMessage::_internal_has_passthrough() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_UserMessage::has_passthrough() const {
  return _internal_has_passthrough();
}
inline void CSVCMsg_UserMessage::clear_passthrough() {
  _impl_.passthrough_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CSVCMsg_UserMessage::_internal_passthrough() const {
  return _impl_.passthrough_;
}
inline int32_t CSVCMsg_UserMessage::passthrough() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_UserMessage.passthrough)
  return _internal_passthrough();
}
inline void CSVCMsg_UserMessage::_internal_set_passthrough(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.passthrough_ = value;
}
inline void CSVCMsg_UserMessage::set_passthrough(int32_t value) {
  _internal_set_passthrough(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_UserMessage.passthrough)
}

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

// CSVCMsg_SendTable_sendprop_t

// optional int32 type = 1;
inline bool CSVCMsg_SendTable_sendprop_t::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_SendTable_sendprop_t::has_type() const {
  return _internal_has_type();
}
inline void CSVCMsg_SendTable_sendprop_t::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CSVCMsg_SendTable_sendprop_t::_internal_type() const {
  return _impl_.type_;
}
inline int32_t CSVCMsg_SendTable_sendprop_t::type() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SendTable.sendprop_t.type)
  return _internal_type();
}
inline void CSVCMsg_SendTable_sendprop_t::_internal_set_type(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.type_ = value;
}
inline void CSVCMsg_SendTable_sendprop_t::set_type(int32_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_SendTable.sendprop_t.type)
}

// optional string var_name = 2;
inline bool CSVCMsg_SendTable_sendprop_t::_internal_has_var_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_SendTable_sendprop_t::has_var_name() const {
  return _internal_has_var_name();
}
inline void CSVCMsg_SendTable_sendprop_t::clear_var_name() {
  _impl_.var_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_SendTable_sendprop_t::var_name() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SendTable.sendprop_t.var_name)
  return _internal_var_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_SendTable_sendprop_t::set_var_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.var_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_SendTable.sendprop_t.var_name)
}
inline std::string* CSVCMsg_SendTable_sendprop_t::mutable_var_name() {
  std::string* _s = _internal_mutable_var_name();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_SendTable.sendprop_t.var_name)
  return _s;
}
inline const std::string& CSVCMsg_SendTable_sendprop_t::_internal_var_name() const {
  return _impl_.var_name_.Get();
}
inline void CSVCMsg_SendTable_sendprop_t::_internal_set_var_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.var_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_SendTable_sendprop_t::_internal_mutable_var_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.var_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_SendTable_sendprop_t::release_var_name() {
  // @@protoc_insertion_point(field_release:CSVCMsg_SendTable.sendprop_t.var_name)
  if (!_internal_has_var_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.var_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.var_name_.IsDefault()) {
    _impl_.var_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_SendTable_sendprop_t::set_allocated_var_name(std::string* var_name) {
  if (var_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.var_name_.SetAllocated(var_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.var_name_.IsDefault()) {
    _impl_.var_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_SendTable.sendprop_t.var_name)
}

// optional int32 flags = 3;
inline bool CSVCMsg_SendTable_sendprop_t::_internal_has_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSVCMsg_SendTable_sendprop_t::has_flags() const {
  return _internal_has_flags();
}
inline void CSVCMsg_SendTable_sendprop_t::clear_flags() {
  _impl_.flags_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CSVCMsg_SendTable_sendprop_t::_internal_flags() const {
  return _impl_.flags_;
}
inline int32_t CSVCMsg_SendTable_sendprop_t::flags() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SendTable.sendprop_t.flags)
  return _internal_flags();
}
inline void CSVCMsg_SendTable_sendprop_t::_internal_set_flags(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.flags_ = value;
}
inline void CSVCMsg_SendTable_sendprop_t::set_flags(int32_t value) {
  _internal_set_flags(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_SendTable.sendprop_t.flags)
}

// optional int32 priority = 4;
inline bool CSVCMsg_SendTable_sendprop_t::_internal_has_priority() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSVCMsg_SendTable_sendprop_t::has_priority() const {
  return _internal_has_priority();
}
inline void CSVCMsg_SendTable_sendprop_t::clear_priority() {
  _impl_.priority_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CSVCMsg_SendTable_sendprop_t::_internal_priority() const {
  return _impl_.priority_;
}
inline int32_t CSVCMsg_SendTable_sendprop_t::priority() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SendTable.sendprop_t.priority)
  return _internal_priority();
}
inline void CSVCMsg_SendTable_sendprop_t::_internal_set_priority(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.priority_ = value;
}
inline void CSVCMsg_SendTable_sendprop_t::set_priority(int32_t value) {
  _internal_set_priority(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_SendTable.sendprop_t.priority)
}

// optional string dt_name = 5;
inline bool CSVCMsg_SendTable_sendprop_t::_internal_has_dt_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_SendTable_sendprop_t::has_dt_name() const {
  return _internal_has_dt_name();
}
inline void CSVCMsg_SendTable_sendprop_t::clear_dt_name() {
  _impl_.dt_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CSVCMsg_SendTable_sendprop_t::dt_name() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SendTable.sendprop_t.dt_name)
  return _internal_dt_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_SendTable_sendprop_t::set_dt_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.dt_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_SendTable.sendprop_t.dt_name)
}
inline std::string* CSVCMsg_SendTable_sendprop_t::mutable_dt_name() {
  std::string* _s = _internal_mutable_dt_name();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_SendTable.sendprop_t.dt_name)
  return _s;
}
inline const std::string& CSVCMsg_SendTable_sendprop_t::_internal_dt_name() const {
  return _impl_.dt_name_.Get();
}
inline void CSVCMsg_SendTable_sendprop_t::_internal_set_dt_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.dt_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_SendTable_sendprop_t::_internal_mutable_dt_name() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.dt_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_SendTable_sendprop_t::release_dt_name() {
  // @@protoc_insertion_point(field_release:CSVCMsg_SendTable.sendprop_t.dt_name)
  if (!_internal_has_dt_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.dt_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dt_name_.IsDefault()) {
    _impl_.dt_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_SendTable_sendprop_t::set_allocated_dt_name(std::string* dt_name) {
  if (dt_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.dt_name_.SetAllocated(dt_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dt_name_.IsDefault()) {
    _impl_.dt_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_SendTable.sendprop_t.dt_name)
}

// optional int32 num_elements = 6;
inline bool CSVCMsg_SendTable_sendprop_t::_internal_has_num_elements() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CSVCMsg_SendTable_sendprop_t::has_num_elements() const {
  return _internal_has_num_elements();
}
inline void CSVCMsg_SendTable_sendprop_t::clear_num_elements() {
  _impl_.num_elements_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CSVCMsg_SendTable_sendprop_t::_internal_num_elements() const {
  return _impl_.num_elements_;
}
inline int32_t CSVCMsg_SendTable_sendprop_t::num_elements() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SendTable.sendprop_t.num_elements)
  return _internal_num_elements();
}
inline void CSVCMsg_SendTable_sendprop_t::_internal_set_num_elements(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.num_elements_ = value;
}
inline void CSVCMsg_SendTable_sendprop_t::set_num_elements(int32_t value) {
  _internal_set_num_elements(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_SendTable.sendprop_t.num_elements)
}

// optional float low_value = 7;
inline bool CSVCMsg_SendTable_sendprop_t::_internal_has_low_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CSVCMsg_SendTable_sendprop_t::has_low_value() const {
  return _internal_has_low_value();
}
inline void CSVCMsg_SendTable_sendprop_t::clear_low_value() {
  _impl_.low_value_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float CSVCMsg_SendTable_sendprop_t::_internal_low_value() const {
  return _impl_.low_value_;
}
inline float CSVCMsg_SendTable_sendprop_t::low_value() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SendTable.sendprop_t.low_value)
  return _internal_low_value();
}
inline void CSVCMsg_SendTable_sendprop_t::_internal_set_low_value(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.low_value_ = value;
}
inline void CSVCMsg_SendTable_sendprop_t::set_low_value(float value) {
  _internal_set_low_value(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_SendTable.sendprop_t.low_value)
}

// optional float high_value = 8;
inline bool CSVCMsg_SendTable_sendprop_t::_internal_has_high_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CSVCMsg_SendTable_sendprop_t::has_high_value() const {
  return _internal_has_high_value();
}
inline void CSVCMsg_SendTable_sendprop_t::clear_high_value() {
  _impl_.high_value_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline float CSVCMsg_SendTable_sendprop_t::_internal_high_value() const {
  return _impl_.high_value_;
}
inline float CSVCMsg_SendTable_sendprop_t::high_value() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SendTable.sendprop_t.high_value)
  return _internal_high_value();
}
inline void CSVCMsg_SendTable_sendprop_t::_internal_set_high_value(float value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.high_value_ = value;
}
inline void CSVCMsg_SendTable_sendprop_t::set_high_value(float value) {
  _internal_set_high_value(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_SendTable.sendprop_t.high_value)
}

// optional int32 num_bits = 9;
inline bool CSVCMsg_SendTable_sendprop_t::_internal_has_num_bits() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CSVCMsg_SendTable_sendprop_t::has_num_bits() const {
  return _internal_has_num_bits();
}
inline void CSVCMsg_SendTable_sendprop_t::clear_num_bits() {
  _impl_.num_bits_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int32_t CSVCMsg_SendTable_sendprop_t::_internal_num_bits() const {
  return _impl_.num_bits_;
}
inline int32_t CSVCMsg_SendTable_sendprop_t::num_bits() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SendTable.sendprop_t.num_bits)
  return _internal_num_bits();
}
inline void CSVCMsg_SendTable_sendprop_t::_internal_set_num_bits(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.num_bits_ = value;
}
inline void CSVCMsg_SendTable_sendprop_t::set_num_bits(int32_t value) {
  _internal_set_num_bits(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_SendTable.sendprop_t.num_bits)
}

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

// CSVCMsg_SendTable

// optional bool is_end = 1;
inline bool CSVCMsg_SendTable::_internal_has_is_end() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_SendTable::has_is_end() const {
  return _internal_has_is_end();
}
inline void CSVCMsg_SendTable::clear_is_end() {
  _impl_.is_end_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CSVCMsg_SendTable::_internal_is_end() const {
  return _impl_.is_end_;
}
inline bool CSVCMsg_SendTable::is_end() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SendTable.is_end)
  return _internal_is_end();
}
inline void CSVCMsg_SendTable::_internal_set_is_end(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.is_end_ = value;
}
inline void CSVCMsg_SendTable::set_is_end(bool value) {
  _internal_set_is_end(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_SendTable.is_end)
}

// optional string net_table_name = 2;
inline bool CSVCMsg_SendTable::_internal_has_net_table_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_SendTable::has_net_table_name() const {
  return _internal_has_net_table_name();
}
inline void CSVCMsg_SendTable::clear_net_table_name() {
  _impl_.net_table_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_SendTable::net_table_name() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SendTable.net_table_name)
  return _internal_net_table_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_SendTable::set_net_table_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.net_table_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_SendTable.net_table_name)
}
inline std::string* CSVCMsg_SendTable::mutable_net_table_name() {
  std::string* _s = _internal_mutable_net_table_name();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_SendTable.net_table_name)
  return _s;
}
inline const std::string& CSVCMsg_SendTable::_internal_net_table_name() const {
  return _impl_.net_table_name_.Get();
}
inline void CSVCMsg_SendTable::_internal_set_net_table_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.net_table_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_SendTable::_internal_mutable_net_table_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.net_table_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_SendTable::release_net_table_name() {
  // @@protoc_insertion_point(field_release:CSVCMsg_SendTable.net_table_name)
  if (!_internal_has_net_table_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.net_table_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.net_table_name_.IsDefault()) {
    _impl_.net_table_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_SendTable::set_allocated_net_table_name(std::string* net_table_name) {
  if (net_table_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.net_table_name_.SetAllocated(net_table_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.net_table_name_.IsDefault()) {
    _impl_.net_table_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_SendTable.net_table_name)
}

// optional bool needs_decoder = 3;
inline bool CSVCMsg_SendTable::_internal_has_needs_decoder() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_SendTable::has_needs_decoder() const {
  return _internal_has_needs_decoder();
}
inline void CSVCMsg_SendTable::clear_needs_decoder() {
  _impl_.needs_decoder_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CSVCMsg_SendTable::_internal_needs_decoder() const {
  return _impl_.needs_decoder_;
}
inline bool CSVCMsg_SendTable::needs_decoder() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SendTable.needs_decoder)
  return _internal_needs_decoder();
}
inline void CSVCMsg_SendTable::_internal_set_needs_decoder(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.needs_decoder_ = value;
}
inline void CSVCMsg_SendTable::set_needs_decoder(bool value) {
  _internal_set_needs_decoder(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_SendTable.needs_decoder)
}

// repeated .CSVCMsg_SendTable.sendprop_t props = 4;
inline int CSVCMsg_SendTable::_internal_props_size() const {
  return _impl_.props_.size();
}
inline int CSVCMsg_SendTable::props_size() const {
  return _internal_props_size();
}
inline void CSVCMsg_SendTable::clear_props() {
  _impl_.props_.Clear();
}
inline ::CSVCMsg_SendTable_sendprop_t* CSVCMsg_SendTable::mutable_props(int index) {
  // @@protoc_insertion_point(field_mutable:CSVCMsg_SendTable.props)
  return _impl_.props_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_SendTable_sendprop_t >*
CSVCMsg_SendTable::mutable_props() {
  // @@protoc_insertion_point(field_mutable_list:CSVCMsg_SendTable.props)
  return &_impl_.props_;
}
inline const ::CSVCMsg_SendTable_sendprop_t& CSVCMsg_SendTable::_internal_props(int index) const {
  return _impl_.props_.Get(index);
}
inline const ::CSVCMsg_SendTable_sendprop_t& CSVCMsg_SendTable::props(int index) const {
  // @@protoc_insertion_point(field_get:CSVCMsg_SendTable.props)
  return _internal_props(index);
}
inline ::CSVCMsg_SendTable_sendprop_t* CSVCMsg_SendTable::_internal_add_props() {
  return _impl_.props_.Add();
}
inline ::CSVCMsg_SendTable_sendprop_t* CSVCMsg_SendTable::add_props() {
  ::CSVCMsg_SendTable_sendprop_t* _add = _internal_add_props();
  // @@protoc_insertion_point(field_add:CSVCMsg_SendTable.props)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_SendTable_sendprop_t >&
CSVCMsg_SendTable::props() const {
  // @@protoc_insertion_point(field_list:CSVCMsg_SendTable.props)
  return _impl_.props_;
}

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

// CSVCMsg_GameEventList_key_t

// optional int32 type = 1;
inline bool CSVCMsg_GameEventList_key_t::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_GameEventList_key_t::has_type() const {
  return _internal_has_type();
}
inline void CSVCMsg_GameEventList_key_t::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_GameEventList_key_t::_internal_type() const {
  return _impl_.type_;
}
inline int32_t CSVCMsg_GameEventList_key_t::type() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEventList.key_t.type)
  return _internal_type();
}
inline void CSVCMsg_GameEventList_key_t::_internal_set_type(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.type_ = value;
}
inline void CSVCMsg_GameEventList_key_t::set_type(int32_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameEventList.key_t.type)
}

// optional string name = 2;
inline bool CSVCMsg_GameEventList_key_t::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_GameEventList_key_t::has_name() const {
  return _internal_has_name();
}
inline void CSVCMsg_GameEventList_key_t::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_GameEventList_key_t::name() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEventList.key_t.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_GameEventList_key_t::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_GameEventList.key_t.name)
}
inline std::string* CSVCMsg_GameEventList_key_t::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GameEventList.key_t.name)
  return _s;
}
inline const std::string& CSVCMsg_GameEventList_key_t::_internal_name() const {
  return _impl_.name_.Get();
}
inline void CSVCMsg_GameEventList_key_t::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameEventList_key_t::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameEventList_key_t::release_name() {
  // @@protoc_insertion_point(field_release:CSVCMsg_GameEventList.key_t.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_GameEventList_key_t::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_GameEventList.key_t.name)
}

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

// CSVCMsg_GameEventList_descriptor_t

// optional int32 eventid = 1;
inline bool CSVCMsg_GameEventList_descriptor_t::_internal_has_eventid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_GameEventList_descriptor_t::has_eventid() const {
  return _internal_has_eventid();
}
inline void CSVCMsg_GameEventList_descriptor_t::clear_eventid() {
  _impl_.eventid_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_GameEventList_descriptor_t::_internal_eventid() const {
  return _impl_.eventid_;
}
inline int32_t CSVCMsg_GameEventList_descriptor_t::eventid() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEventList.descriptor_t.eventid)
  return _internal_eventid();
}
inline void CSVCMsg_GameEventList_descriptor_t::_internal_set_eventid(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.eventid_ = value;
}
inline void CSVCMsg_GameEventList_descriptor_t::set_eventid(int32_t value) {
  _internal_set_eventid(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameEventList.descriptor_t.eventid)
}

// optional string name = 2;
inline bool CSVCMsg_GameEventList_descriptor_t::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_GameEventList_descriptor_t::has_name() const {
  return _internal_has_name();
}
inline void CSVCMsg_GameEventList_descriptor_t::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_GameEventList_descriptor_t::name() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEventList.descriptor_t.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_GameEventList_descriptor_t::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_GameEventList.descriptor_t.name)
}
inline std::string* CSVCMsg_GameEventList_descriptor_t::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GameEventList.descriptor_t.name)
  return _s;
}
inline const std::string& CSVCMsg_GameEventList_descriptor_t::_internal_name() const {
  return _impl_.name_.Get();
}
inline void CSVCMsg_GameEventList_descriptor_t::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameEventList_descriptor_t::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameEventList_descriptor_t::release_name() {
  // @@protoc_insertion_point(field_release:CSVCMsg_GameEventList.descriptor_t.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_GameEventList_descriptor_t::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_GameEventList.descriptor_t.name)
}

// repeated .CSVCMsg_GameEventList.key_t keys = 3;
inline int CSVCMsg_GameEventList_descriptor_t::_internal_keys_size() const {
  return _impl_.keys_.size();
}
inline int CSVCMsg_GameEventList_descriptor_t::keys_size() const {
  return _internal_keys_size();
}
inline void CSVCMsg_GameEventList_descriptor_t::clear_keys() {
  _impl_.keys_.Clear();
}
inline ::CSVCMsg_GameEventList_key_t* CSVCMsg_GameEventList_descriptor_t::mutable_keys(int index) {
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GameEventList.descriptor_t.keys)
  return _impl_.keys_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_GameEventList_key_t >*
CSVCMsg_GameEventList_descriptor_t::mutable_keys() {
  // @@protoc_insertion_point(field_mutable_list:CSVCMsg_GameEventList.descriptor_t.keys)
  return &_impl_.keys_;
}
inline const ::CSVCMsg_GameEventList_key_t& CSVCMsg_GameEventList_descriptor_t::_internal_keys(int index) const {
  return _impl_.keys_.Get(index);
}
inline const ::CSVCMsg_GameEventList_key_t& CSVCMsg_GameEventList_descriptor_t::keys(int index) const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEventList.descriptor_t.keys)
  return _internal_keys(index);
}
inline ::CSVCMsg_GameEventList_key_t* CSVCMsg_GameEventList_descriptor_t::_internal_add_keys() {
  return _impl_.keys_.Add();
}
inline ::CSVCMsg_GameEventList_key_t* CSVCMsg_GameEventList_descriptor_t::add_keys() {
  ::CSVCMsg_GameEventList_key_t* _add = _internal_add_keys();
  // @@protoc_insertion_point(field_add:CSVCMsg_GameEventList.descriptor_t.keys)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_GameEventList_key_t >&
CSVCMsg_GameEventList_descriptor_t::keys() const {
  // @@protoc_insertion_point(field_list:CSVCMsg_GameEventList.descriptor_t.keys)
  return _impl_.keys_;
}

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

// CSVCMsg_GameEventList

// repeated .CSVCMsg_GameEventList.descriptor_t descriptors = 1;
inline int CSVCMsg_GameEventList::_internal_descriptors_size() const {
  return _impl_.descriptors_.size();
}
inline int CSVCMsg_GameEventList::descriptors_size() const {
  return _internal_descriptors_size();
}
inline void CSVCMsg_GameEventList::clear_descriptors() {
  _impl_.descriptors_.Clear();
}
inline ::CSVCMsg_GameEventList_descriptor_t* CSVCMsg_GameEventList::mutable_descriptors(int index) {
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GameEventList.descriptors)
  return _impl_.descriptors_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_GameEventList_descriptor_t >*
CSVCMsg_GameEventList::mutable_descriptors() {
  // @@protoc_insertion_point(field_mutable_list:CSVCMsg_GameEventList.descriptors)
  return &_impl_.descriptors_;
}
inline const ::CSVCMsg_GameEventList_descriptor_t& CSVCMsg_GameEventList::_internal_descriptors(int index) const {
  return _impl_.descriptors_.Get(index);
}
inline const ::CSVCMsg_GameEventList_descriptor_t& CSVCMsg_GameEventList::descriptors(int index) const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEventList.descriptors)
  return _internal_descriptors(index);
}
inline ::CSVCMsg_GameEventList_descriptor_t* CSVCMsg_GameEventList::_internal_add_descriptors() {
  return _impl_.descriptors_.Add();
}
inline ::CSVCMsg_GameEventList_descriptor_t* CSVCMsg_GameEventList::add_descriptors() {
  ::CSVCMsg_GameEventList_descriptor_t* _add = _internal_add_descriptors();
  // @@protoc_insertion_point(field_add:CSVCMsg_GameEventList.descriptors)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_GameEventList_descriptor_t >&
CSVCMsg_GameEventList::descriptors() const {
  // @@protoc_insertion_point(field_list:CSVCMsg_GameEventList.descriptors)
  return _impl_.descriptors_;
}

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

// CSVCMsg_PacketEntities_alternate_baseline_t

// optional int32 entity_index = 1;
inline bool CSVCMsg_PacketEntities_alternate_baseline_t::_internal_has_entity_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities_alternate_baseline_t::has_entity_index() const {
  return _internal_has_entity_index();
}
inline void CSVCMsg_PacketEntities_alternate_baseline_t::clear_entity_index() {
  _impl_.entity_index_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CSVCMsg_PacketEntities_alternate_baseline_t::_internal_entity_index() const {
  return _impl_.entity_index_;
}
inline int32_t CSVCMsg_PacketEntities_alternate_baseline_t::entity_index() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.alternate_baseline_t.entity_index)
  return _internal_entity_index();
}
inline void CSVCMsg_PacketEntities_alternate_baseline_t::_internal_set_entity_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.entity_index_ = value;
}
inline void CSVCMsg_PacketEntities_alternate_baseline_t::set_entity_index(int32_t value) {
  _internal_set_entity_index(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.alternate_baseline_t.entity_index)
}

// optional int32 baseline_index = 2;
inline bool CSVCMsg_PacketEntities_alternate_baseline_t::_internal_has_baseline_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities_alternate_baseline_t::has_baseline_index() const {
  return _internal_has_baseline_index();
}
inline void CSVCMsg_PacketEntities_alternate_baseline_t::clear_baseline_index() {
  _impl_.baseline_index_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_PacketEntities_alternate_baseline_t::_internal_baseline_index() const {
  return _impl_.baseline_index_;
}
inline int32_t CSVCMsg_PacketEntities_alternate_baseline_t::baseline_index() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.alternate_baseline_t.baseline_index)
  return _internal_baseline_index();
}
inline void CSVCMsg_PacketEntities_alternate_baseline_t::_internal_set_baseline_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.baseline_index_ = value;
}
inline void CSVCMsg_PacketEntities_alternate_baseline_t::set_baseline_index(int32_t value) {
  _internal_set_baseline_index(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.alternate_baseline_t.baseline_index)
}

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

// CSVCMsg_PacketEntities_non_transmitted_entities_t

// optional int32 header_count = 1;
inline bool CSVCMsg_PacketEntities_non_transmitted_entities_t::_internal_has_header_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities_non_transmitted_entities_t::has_header_count() const {
  return _internal_has_header_count();
}
inline void CSVCMsg_PacketEntities_non_transmitted_entities_t::clear_header_count() {
  _impl_.header_count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_PacketEntities_non_transmitted_entities_t::_internal_header_count() const {
  return _impl_.header_count_;
}
inline int32_t CSVCMsg_PacketEntities_non_transmitted_entities_t::header_count() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.non_transmitted_entities_t.header_count)
  return _internal_header_count();
}
inline void CSVCMsg_PacketEntities_non_transmitted_entities_t::_internal_set_header_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.header_count_ = value;
}
inline void CSVCMsg_PacketEntities_non_transmitted_entities_t::set_header_count(int32_t value) {
  _internal_set_header_count(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.non_transmitted_entities_t.header_count)
}

// optional bytes data = 2;
inline bool CSVCMsg_PacketEntities_non_transmitted_entities_t::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities_non_transmitted_entities_t::has_data() const {
  return _internal_has_data();
}
inline void CSVCMsg_PacketEntities_non_transmitted_entities_t::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_PacketEntities_non_transmitted_entities_t::data() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.non_transmitted_entities_t.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_PacketEntities_non_transmitted_entities_t::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.non_transmitted_entities_t.data)
}
inline std::string* CSVCMsg_PacketEntities_non_transmitted_entities_t::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_PacketEntities.non_transmitted_entities_t.data)
  return _s;
}
inline const std::string& CSVCMsg_PacketEntities_non_transmitted_entities_t::_internal_data() const {
  return _impl_.data_.Get();
}
inline void CSVCMsg_PacketEntities_non_transmitted_entities_t::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_PacketEntities_non_transmitted_entities_t::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_PacketEntities_non_transmitted_entities_t::release_data() {
  // @@protoc_insertion_point(field_release:CSVCMsg_PacketEntities.non_transmitted_entities_t.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_PacketEntities_non_transmitted_entities_t::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_PacketEntities.non_transmitted_entities_t.data)
}

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

// CSVCMsg_PacketEntities_outofpvs_entity_updates_t

// optional int32 count = 1;
inline bool CSVCMsg_PacketEntities_outofpvs_entity_updates_t::_internal_has_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities_outofpvs_entity_updates_t::has_count() const {
  return _internal_has_count();
}
inline void CSVCMsg_PacketEntities_outofpvs_entity_updates_t::clear_count() {
  _impl_.count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_PacketEntities_outofpvs_entity_updates_t::_internal_count() const {
  return _impl_.count_;
}
inline int32_t CSVCMsg_PacketEntities_outofpvs_entity_updates_t::count() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.outofpvs_entity_updates_t.count)
  return _internal_count();
}
inline void CSVCMsg_PacketEntities_outofpvs_entity_updates_t::_internal_set_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.count_ = value;
}
inline void CSVCMsg_PacketEntities_outofpvs_entity_updates_t::set_count(int32_t value) {
  _internal_set_count(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.outofpvs_entity_updates_t.count)
}

// optional bytes data = 2;
inline bool CSVCMsg_PacketEntities_outofpvs_entity_updates_t::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities_outofpvs_entity_updates_t::has_data() const {
  return _internal_has_data();
}
inline void CSVCMsg_PacketEntities_outofpvs_entity_updates_t::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_PacketEntities_outofpvs_entity_updates_t::data() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.outofpvs_entity_updates_t.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_PacketEntities_outofpvs_entity_updates_t::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.outofpvs_entity_updates_t.data)
}
inline std::string* CSVCMsg_PacketEntities_outofpvs_entity_updates_t::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_PacketEntities.outofpvs_entity_updates_t.data)
  return _s;
}
inline const std::string& CSVCMsg_PacketEntities_outofpvs_entity_updates_t::_internal_data() const {
  return _impl_.data_.Get();
}
inline void CSVCMsg_PacketEntities_outofpvs_entity_updates_t::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_PacketEntities_outofpvs_entity_updates_t::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_PacketEntities_outofpvs_entity_updates_t::release_data() {
  // @@protoc_insertion_point(field_release:CSVCMsg_PacketEntities.outofpvs_entity_updates_t.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_PacketEntities_outofpvs_entity_updates_t::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_PacketEntities.outofpvs_entity_updates_t.data)
}

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

// CSVCMsg_PacketEntities

// optional int32 max_entries = 1;
inline bool CSVCMsg_PacketEntities::_internal_has_max_entries() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_max_entries() const {
  return _internal_has_max_entries();
}
inline void CSVCMsg_PacketEntities::clear_max_entries() {
  _impl_.max_entries_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CSVCMsg_PacketEntities::_internal_max_entries() const {
  return _impl_.max_entries_;
}
inline int32_t CSVCMsg_PacketEntities::max_entries() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.max_entries)
  return _internal_max_entries();
}
inline void CSVCMsg_PacketEntities::_internal_set_max_entries(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.max_entries_ = value;
}
inline void CSVCMsg_PacketEntities::set_max_entries(int32_t value) {
  _internal_set_max_entries(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.max_entries)
}

// optional int32 updated_entries = 2;
inline bool CSVCMsg_PacketEntities::_internal_has_updated_entries() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_updated_entries() const {
  return _internal_has_updated_entries();
}
inline void CSVCMsg_PacketEntities::clear_updated_entries() {
  _impl_.updated_entries_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t CSVCMsg_PacketEntities::_internal_updated_entries() const {
  return _impl_.updated_entries_;
}
inline int32_t CSVCMsg_PacketEntities::updated_entries() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.updated_entries)
  return _internal_updated_entries();
}
inline void CSVCMsg_PacketEntities::_internal_set_updated_entries(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.updated_entries_ = value;
}
inline void CSVCMsg_PacketEntities::set_updated_entries(int32_t value) {
  _internal_set_updated_entries(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.updated_entries)
}

// optional bool legacy_is_delta = 3;
inline bool CSVCMsg_PacketEntities::_internal_has_legacy_is_delta() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_legacy_is_delta() const {
  return _internal_has_legacy_is_delta();
}
inline void CSVCMsg_PacketEntities::clear_legacy_is_delta() {
  _impl_.legacy_is_delta_ = false;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline bool CSVCMsg_PacketEntities::_internal_legacy_is_delta() const {
  return _impl_.legacy_is_delta_;
}
inline bool CSVCMsg_PacketEntities::legacy_is_delta() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.legacy_is_delta)
  return _internal_legacy_is_delta();
}
inline void CSVCMsg_PacketEntities::_internal_set_legacy_is_delta(bool value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.legacy_is_delta_ = value;
}
inline void CSVCMsg_PacketEntities::set_legacy_is_delta(bool value) {
  _internal_set_legacy_is_delta(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.legacy_is_delta)
}

// optional bool update_baseline = 4;
inline bool CSVCMsg_PacketEntities::_internal_has_update_baseline() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_update_baseline() const {
  return _internal_has_update_baseline();
}
inline void CSVCMsg_PacketEntities::clear_update_baseline() {
  _impl_.update_baseline_ = false;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline bool CSVCMsg_PacketEntities::_internal_update_baseline() const {
  return _impl_.update_baseline_;
}
inline bool CSVCMsg_PacketEntities::update_baseline() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.update_baseline)
  return _internal_update_baseline();
}
inline void CSVCMsg_PacketEntities::_internal_set_update_baseline(bool value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.update_baseline_ = value;
}
inline void CSVCMsg_PacketEntities::set_update_baseline(bool value) {
  _internal_set_update_baseline(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.update_baseline)
}

// optional int32 baseline = 5;
inline bool CSVCMsg_PacketEntities::_internal_has_baseline() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_baseline() const {
  return _internal_has_baseline();
}
inline void CSVCMsg_PacketEntities::clear_baseline() {
  _impl_.baseline_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t CSVCMsg_PacketEntities::_internal_baseline() const {
  return _impl_.baseline_;
}
inline int32_t CSVCMsg_PacketEntities::baseline() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.baseline)
  return _internal_baseline();
}
inline void CSVCMsg_PacketEntities::_internal_set_baseline(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.baseline_ = value;
}
inline void CSVCMsg_PacketEntities::set_baseline(int32_t value) {
  _internal_set_baseline(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.baseline)
}

// optional int32 delta_from = 6;
inline bool CSVCMsg_PacketEntities::_internal_has_delta_from() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_delta_from() const {
  return _internal_has_delta_from();
}
inline void CSVCMsg_PacketEntities::clear_delta_from() {
  _impl_.delta_from_ = 0;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline int32_t CSVCMsg_PacketEntities::_internal_delta_from() const {
  return _impl_.delta_from_;
}
inline int32_t CSVCMsg_PacketEntities::delta_from() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.delta_from)
  return _internal_delta_from();
}
inline void CSVCMsg_PacketEntities::_internal_set_delta_from(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.delta_from_ = value;
}
inline void CSVCMsg_PacketEntities::set_delta_from(int32_t value) {
  _internal_set_delta_from(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.delta_from)
}

// optional bytes entity_data = 7;
inline bool CSVCMsg_PacketEntities::_internal_has_entity_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_entity_data() const {
  return _internal_has_entity_data();
}
inline void CSVCMsg_PacketEntities::clear_entity_data() {
  _impl_.entity_data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_PacketEntities::entity_data() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.entity_data)
  return _internal_entity_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_PacketEntities::set_entity_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.entity_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.entity_data)
}
inline std::string* CSVCMsg_PacketEntities::mutable_entity_data() {
  std::string* _s = _internal_mutable_entity_data();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_PacketEntities.entity_data)
  return _s;
}
inline const std::string& CSVCMsg_PacketEntities::_internal_entity_data() const {
  return _impl_.entity_data_.Get();
}
inline void CSVCMsg_PacketEntities::_internal_set_entity_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.entity_data_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_PacketEntities::_internal_mutable_entity_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.entity_data_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_PacketEntities::release_entity_data() {
  // @@protoc_insertion_point(field_release:CSVCMsg_PacketEntities.entity_data)
  if (!_internal_has_entity_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.entity_data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.entity_data_.IsDefault()) {
    _impl_.entity_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_PacketEntities::set_allocated_entity_data(std::string* entity_data) {
  if (entity_data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.entity_data_.SetAllocated(entity_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.entity_data_.IsDefault()) {
    _impl_.entity_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_PacketEntities.entity_data)
}

// optional bool pending_full_frame = 8;
inline bool CSVCMsg_PacketEntities::_internal_has_pending_full_frame() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_pending_full_frame() const {
  return _internal_has_pending_full_frame();
}
inline void CSVCMsg_PacketEntities::clear_pending_full_frame() {
  _impl_.pending_full_frame_ = false;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline bool CSVCMsg_PacketEntities::_internal_pending_full_frame() const {
  return _impl_.pending_full_frame_;
}
inline bool CSVCMsg_PacketEntities::pending_full_frame() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.pending_full_frame)
  return _internal_pending_full_frame();
}
inline void CSVCMsg_PacketEntities::_internal_set_pending_full_frame(bool value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.pending_full_frame_ = value;
}
inline void CSVCMsg_PacketEntities::set_pending_full_frame(bool value) {
  _internal_set_pending_full_frame(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.pending_full_frame)
}

// optional uint32 active_spawngroup_handle = 9;
inline bool CSVCMsg_PacketEntities::_internal_has_active_spawngroup_handle() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_active_spawngroup_handle() const {
  return _internal_has_active_spawngroup_handle();
}
inline void CSVCMsg_PacketEntities::clear_active_spawngroup_handle() {
  _impl_.active_spawngroup_handle_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t CSVCMsg_PacketEntities::_internal_active_spawngroup_handle() const {
  return _impl_.active_spawngroup_handle_;
}
inline uint32_t CSVCMsg_PacketEntities::active_spawngroup_handle() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.active_spawngroup_handle)
  return _internal_active_spawngroup_handle();
}
inline void CSVCMsg_PacketEntities::_internal_set_active_spawngroup_handle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.active_spawngroup_handle_ = value;
}
inline void CSVCMsg_PacketEntities::set_active_spawngroup_handle(uint32_t value) {
  _internal_set_active_spawngroup_handle(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.active_spawngroup_handle)
}

// optional uint32 max_spawngroup_creationsequence = 10;
inline bool CSVCMsg_PacketEntities::_internal_has_max_spawngroup_creationsequence() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_max_spawngroup_creationsequence() const {
  return _internal_has_max_spawngroup_creationsequence();
}
inline void CSVCMsg_PacketEntities::clear_max_spawngroup_creationsequence() {
  _impl_.max_spawngroup_creationsequence_ = 0u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t CSVCMsg_PacketEntities::_internal_max_spawngroup_creationsequence() const {
  return _impl_.max_spawngroup_creationsequence_;
}
inline uint32_t CSVCMsg_PacketEntities::max_spawngroup_creationsequence() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.max_spawngroup_creationsequence)
  return _internal_max_spawngroup_creationsequence();
}
inline void CSVCMsg_PacketEntities::_internal_set_max_spawngroup_creationsequence(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.max_spawngroup_creationsequence_ = value;
}
inline void CSVCMsg_PacketEntities::set_max_spawngroup_creationsequence(uint32_t value) {
  _internal_set_max_spawngroup_creationsequence(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.max_spawngroup_creationsequence)
}

// optional uint32 last_cmd_number_executed = 11;
inline bool CSVCMsg_PacketEntities::_internal_has_last_cmd_number_executed() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_last_cmd_number_executed() const {
  return _internal_has_last_cmd_number_executed();
}
inline void CSVCMsg_PacketEntities::clear_last_cmd_number_executed() {
  _impl_.last_cmd_number_executed_ = 0u;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint32_t CSVCMsg_PacketEntities::_internal_last_cmd_number_executed() const {
  return _impl_.last_cmd_number_executed_;
}
inline uint32_t CSVCMsg_PacketEntities::last_cmd_number_executed() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.last_cmd_number_executed)
  return _internal_last_cmd_number_executed();
}
inline void CSVCMsg_PacketEntities::_internal_set_last_cmd_number_executed(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.last_cmd_number_executed_ = value;
}
inline void CSVCMsg_PacketEntities::set_last_cmd_number_executed(uint32_t value) {
  _internal_set_last_cmd_number_executed(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.last_cmd_number_executed)
}

// optional sint32 last_cmd_number_recv_delta = 17;
inline bool CSVCMsg_PacketEntities::_internal_has_last_cmd_number_recv_delta() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_last_cmd_number_recv_delta() const {
  return _internal_has_last_cmd_number_recv_delta();
}
inline void CSVCMsg_PacketEntities::clear_last_cmd_number_recv_delta() {
  _impl_.last_cmd_number_recv_delta_ = 0;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline int32_t CSVCMsg_PacketEntities::_internal_last_cmd_number_recv_delta() const {
  return _impl_.last_cmd_number_recv_delta_;
}
inline int32_t CSVCMsg_PacketEntities::last_cmd_number_recv_delta() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.last_cmd_number_recv_delta)
  return _internal_last_cmd_number_recv_delta();
}
inline void CSVCMsg_PacketEntities::_internal_set_last_cmd_number_recv_delta(int32_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.last_cmd_number_recv_delta_ = value;
}
inline void CSVCMsg_PacketEntities::set_last_cmd_number_recv_delta(int32_t value) {
  _internal_set_last_cmd_number_recv_delta(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.last_cmd_number_recv_delta)
}

// optional uint32 server_tick = 12;
inline bool CSVCMsg_PacketEntities::_internal_has_server_tick() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_server_tick() const {
  return _internal_has_server_tick();
}
inline void CSVCMsg_PacketEntities::clear_server_tick() {
  _impl_.server_tick_ = 0u;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline uint32_t CSVCMsg_PacketEntities::_internal_server_tick() const {
  return _impl_.server_tick_;
}
inline uint32_t CSVCMsg_PacketEntities::server_tick() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.server_tick)
  return _internal_server_tick();
}
inline void CSVCMsg_PacketEntities::_internal_set_server_tick(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.server_tick_ = value;
}
inline void CSVCMsg_PacketEntities::set_server_tick(uint32_t value) {
  _internal_set_server_tick(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.server_tick)
}

// optional bytes serialized_entities = 13;
inline bool CSVCMsg_PacketEntities::_internal_has_serialized_entities() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_serialized_entities() const {
  return _internal_has_serialized_entities();
}
inline void CSVCMsg_PacketEntities::clear_serialized_entities() {
  _impl_.serialized_entities_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CSVCMsg_PacketEntities::serialized_entities() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.serialized_entities)
  return _internal_serialized_entities();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_PacketEntities::set_serialized_entities(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.serialized_entities_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.serialized_entities)
}
inline std::string* CSVCMsg_PacketEntities::mutable_serialized_entities() {
  std::string* _s = _internal_mutable_serialized_entities();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_PacketEntities.serialized_entities)
  return _s;
}
inline const std::string& CSVCMsg_PacketEntities::_internal_serialized_entities() const {
  return _impl_.serialized_entities_.Get();
}
inline void CSVCMsg_PacketEntities::_internal_set_serialized_entities(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.serialized_entities_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_PacketEntities::_internal_mutable_serialized_entities() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.serialized_entities_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_PacketEntities::release_serialized_entities() {
  // @@protoc_insertion_point(field_release:CSVCMsg_PacketEntities.serialized_entities)
  if (!_internal_has_serialized_entities()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.serialized_entities_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.serialized_entities_.IsDefault()) {
    _impl_.serialized_entities_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_PacketEntities::set_allocated_serialized_entities(std::string* serialized_entities) {
  if (serialized_entities != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.serialized_entities_.SetAllocated(serialized_entities, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.serialized_entities_.IsDefault()) {
    _impl_.serialized_entities_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_PacketEntities.serialized_entities)
}

// repeated .CSVCMsg_PacketEntities.alternate_baseline_t alternate_baselines = 15;
inline int CSVCMsg_PacketEntities::_internal_alternate_baselines_size() const {
  return _impl_.alternate_baselines_.size();
}
inline int CSVCMsg_PacketEntities::alternate_baselines_size() const {
  return _internal_alternate_baselines_size();
}
inline void CSVCMsg_PacketEntities::clear_alternate_baselines() {
  _impl_.alternate_baselines_.Clear();
}
inline ::CSVCMsg_PacketEntities_alternate_baseline_t* CSVCMsg_PacketEntities::mutable_alternate_baselines(int index) {
  // @@protoc_insertion_point(field_mutable:CSVCMsg_PacketEntities.alternate_baselines)
  return _impl_.alternate_baselines_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_PacketEntities_alternate_baseline_t >*
CSVCMsg_PacketEntities::mutable_alternate_baselines() {
  // @@protoc_insertion_point(field_mutable_list:CSVCMsg_PacketEntities.alternate_baselines)
  return &_impl_.alternate_baselines_;
}
inline const ::CSVCMsg_PacketEntities_alternate_baseline_t& CSVCMsg_PacketEntities::_internal_alternate_baselines(int index) const {
  return _impl_.alternate_baselines_.Get(index);
}
inline const ::CSVCMsg_PacketEntities_alternate_baseline_t& CSVCMsg_PacketEntities::alternate_baselines(int index) const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.alternate_baselines)
  return _internal_alternate_baselines(index);
}
inline ::CSVCMsg_PacketEntities_alternate_baseline_t* CSVCMsg_PacketEntities::_internal_add_alternate_baselines() {
  return _impl_.alternate_baselines_.Add();
}
inline ::CSVCMsg_PacketEntities_alternate_baseline_t* CSVCMsg_PacketEntities::add_alternate_baselines() {
  ::CSVCMsg_PacketEntities_alternate_baseline_t* _add = _internal_add_alternate_baselines();
  // @@protoc_insertion_point(field_add:CSVCMsg_PacketEntities.alternate_baselines)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_PacketEntities_alternate_baseline_t >&
CSVCMsg_PacketEntities::alternate_baselines() const {
  // @@protoc_insertion_point(field_list:CSVCMsg_PacketEntities.alternate_baselines)
  return _impl_.alternate_baselines_;
}

// optional uint32 has_pvs_vis_bits_deprecated = 16;
inline bool CSVCMsg_PacketEntities::_internal_has_has_pvs_vis_bits_deprecated() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_has_pvs_vis_bits_deprecated() const {
  return _internal_has_has_pvs_vis_bits_deprecated();
}
inline void CSVCMsg_PacketEntities::clear_has_pvs_vis_bits_deprecated() {
  _impl_.has_pvs_vis_bits_deprecated_ = 0u;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline uint32_t CSVCMsg_PacketEntities::_internal_has_pvs_vis_bits_deprecated() const {
  return _impl_.has_pvs_vis_bits_deprecated_;
}
inline uint32_t CSVCMsg_PacketEntities::has_pvs_vis_bits_deprecated() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.has_pvs_vis_bits_deprecated)
  return _internal_has_pvs_vis_bits_deprecated();
}
inline void CSVCMsg_PacketEntities::_internal_set_has_pvs_vis_bits_deprecated(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.has_pvs_vis_bits_deprecated_ = value;
}
inline void CSVCMsg_PacketEntities::set_has_pvs_vis_bits_deprecated(uint32_t value) {
  _internal_set_has_pvs_vis_bits_deprecated(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.has_pvs_vis_bits_deprecated)
}

// repeated sint32 cmd_recv_status = 22 [packed = true];
inline int CSVCMsg_PacketEntities::_internal_cmd_recv_status_size() const {
  return _impl_.cmd_recv_status_.size();
}
inline int CSVCMsg_PacketEntities::cmd_recv_status_size() const {
  return _internal_cmd_recv_status_size();
}
inline void CSVCMsg_PacketEntities::clear_cmd_recv_status() {
  _impl_.cmd_recv_status_.Clear();
}
inline int32_t CSVCMsg_PacketEntities::_internal_cmd_recv_status(int index) const {
  return _impl_.cmd_recv_status_.Get(index);
}
inline int32_t CSVCMsg_PacketEntities::cmd_recv_status(int index) const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.cmd_recv_status)
  return _internal_cmd_recv_status(index);
}
inline void CSVCMsg_PacketEntities::set_cmd_recv_status(int index, int32_t value) {
  _impl_.cmd_recv_status_.Set(index, value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.cmd_recv_status)
}
inline void CSVCMsg_PacketEntities::_internal_add_cmd_recv_status(int32_t value) {
  _impl_.cmd_recv_status_.Add(value);
}
inline void CSVCMsg_PacketEntities::add_cmd_recv_status(int32_t value) {
  _internal_add_cmd_recv_status(value);
  // @@protoc_insertion_point(field_add:CSVCMsg_PacketEntities.cmd_recv_status)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CSVCMsg_PacketEntities::_internal_cmd_recv_status() const {
  return _impl_.cmd_recv_status_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CSVCMsg_PacketEntities::cmd_recv_status() const {
  // @@protoc_insertion_point(field_list:CSVCMsg_PacketEntities.cmd_recv_status)
  return _internal_cmd_recv_status();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CSVCMsg_PacketEntities::_internal_mutable_cmd_recv_status() {
  return &_impl_.cmd_recv_status_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CSVCMsg_PacketEntities::mutable_cmd_recv_status() {
  // @@protoc_insertion_point(field_mutable_list:CSVCMsg_PacketEntities.cmd_recv_status)
  return _internal_mutable_cmd_recv_status();
}

// optional .CSVCMsg_PacketEntities.non_transmitted_entities_t non_transmitted_entities = 19;
inline bool CSVCMsg_PacketEntities::_internal_has_non_transmitted_entities() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.non_transmitted_entities_ != nullptr);
  return value;
}
inline bool CSVCMsg_PacketEntities::has_non_transmitted_entities() const {
  return _internal_has_non_transmitted_entities();
}
inline void CSVCMsg_PacketEntities::clear_non_transmitted_entities() {
  if (_impl_.non_transmitted_entities_ != nullptr) _impl_.non_transmitted_entities_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::CSVCMsg_PacketEntities_non_transmitted_entities_t& CSVCMsg_PacketEntities::_internal_non_transmitted_entities() const {
  const ::CSVCMsg_PacketEntities_non_transmitted_entities_t* p = _impl_.non_transmitted_entities_;
  return p != nullptr ? *p : reinterpret_cast<const ::CSVCMsg_PacketEntities_non_transmitted_entities_t&>(
      ::_CSVCMsg_PacketEntities_non_transmitted_entities_t_default_instance_);
}
inline const ::CSVCMsg_PacketEntities_non_transmitted_entities_t& CSVCMsg_PacketEntities::non_transmitted_entities() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.non_transmitted_entities)
  return _internal_non_transmitted_entities();
}
inline void CSVCMsg_PacketEntities::unsafe_arena_set_allocated_non_transmitted_entities(
    ::CSVCMsg_PacketEntities_non_transmitted_entities_t* non_transmitted_entities) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.non_transmitted_entities_);
  }
  _impl_.non_transmitted_entities_ = non_transmitted_entities;
  if (non_transmitted_entities) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CSVCMsg_PacketEntities.non_transmitted_entities)
}
inline ::CSVCMsg_PacketEntities_non_transmitted_entities_t* CSVCMsg_PacketEntities::release_non_transmitted_entities() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CSVCMsg_PacketEntities_non_transmitted_entities_t* temp = _impl_.non_transmitted_entities_;
  _impl_.non_transmitted_entities_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CSVCMsg_PacketEntities_non_transmitted_entities_t* CSVCMsg_PacketEntities::unsafe_arena_release_non_transmitted_entities() {
  // @@protoc_insertion_point(field_release:CSVCMsg_PacketEntities.non_transmitted_entities)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CSVCMsg_PacketEntities_non_transmitted_entities_t* temp = _impl_.non_transmitted_entities_;
  _impl_.non_transmitted_entities_ = nullptr;
  return temp;
}
inline ::CSVCMsg_PacketEntities_non_transmitted_entities_t* CSVCMsg_PacketEntities::_internal_mutable_non_transmitted_entities() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.non_transmitted_entities_ == nullptr) {
    auto* p = CreateMaybeMessage<::CSVCMsg_PacketEntities_non_transmitted_entities_t>(GetArenaForAllocation());
    _impl_.non_transmitted_entities_ = p;
  }
  return _impl_.non_transmitted_entities_;
}
inline ::CSVCMsg_PacketEntities_non_transmitted_entities_t* CSVCMsg_PacketEntities::mutable_non_transmitted_entities() {
  ::CSVCMsg_PacketEntities_non_transmitted_entities_t* _msg = _internal_mutable_non_transmitted_entities();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_PacketEntities.non_transmitted_entities)
  return _msg;
}
inline void CSVCMsg_PacketEntities::set_allocated_non_transmitted_entities(::CSVCMsg_PacketEntities_non_transmitted_entities_t* non_transmitted_entities) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.non_transmitted_entities_;
  }
  if (non_transmitted_entities) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(non_transmitted_entities);
    if (message_arena != submessage_arena) {
      non_transmitted_entities = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, non_transmitted_entities, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.non_transmitted_entities_ = non_transmitted_entities;
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_PacketEntities.non_transmitted_entities)
}

// optional uint32 cq_starved_command_ticks = 20;
inline bool CSVCMsg_PacketEntities::_internal_has_cq_starved_command_ticks() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_cq_starved_command_ticks() const {
  return _internal_has_cq_starved_command_ticks();
}
inline void CSVCMsg_PacketEntities::clear_cq_starved_command_ticks() {
  _impl_.cq_starved_command_ticks_ = 0u;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline uint32_t CSVCMsg_PacketEntities::_internal_cq_starved_command_ticks() const {
  return _impl_.cq_starved_command_ticks_;
}
inline uint32_t CSVCMsg_PacketEntities::cq_starved_command_ticks() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.cq_starved_command_ticks)
  return _internal_cq_starved_command_ticks();
}
inline void CSVCMsg_PacketEntities::_internal_set_cq_starved_command_ticks(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.cq_starved_command_ticks_ = value;
}
inline void CSVCMsg_PacketEntities::set_cq_starved_command_ticks(uint32_t value) {
  _internal_set_cq_starved_command_ticks(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.cq_starved_command_ticks)
}

// optional uint32 cq_discarded_command_ticks = 21;
inline bool CSVCMsg_PacketEntities::_internal_has_cq_discarded_command_ticks() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_cq_discarded_command_ticks() const {
  return _internal_has_cq_discarded_command_ticks();
}
inline void CSVCMsg_PacketEntities::clear_cq_discarded_command_ticks() {
  _impl_.cq_discarded_command_ticks_ = 0u;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline uint32_t CSVCMsg_PacketEntities::_internal_cq_discarded_command_ticks() const {
  return _impl_.cq_discarded_command_ticks_;
}
inline uint32_t CSVCMsg_PacketEntities::cq_discarded_command_ticks() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.cq_discarded_command_ticks)
  return _internal_cq_discarded_command_ticks();
}
inline void CSVCMsg_PacketEntities::_internal_set_cq_discarded_command_ticks(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.cq_discarded_command_ticks_ = value;
}
inline void CSVCMsg_PacketEntities::set_cq_discarded_command_ticks(uint32_t value) {
  _internal_set_cq_discarded_command_ticks(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.cq_discarded_command_ticks)
}

// optional .CSVCMsg_PacketEntities.outofpvs_entity_updates_t outofpvs_entity_updates = 23;
inline bool CSVCMsg_PacketEntities::_internal_has_outofpvs_entity_updates() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.outofpvs_entity_updates_ != nullptr);
  return value;
}
inline bool CSVCMsg_PacketEntities::has_outofpvs_entity_updates() const {
  return _internal_has_outofpvs_entity_updates();
}
inline void CSVCMsg_PacketEntities::clear_outofpvs_entity_updates() {
  if (_impl_.outofpvs_entity_updates_ != nullptr) _impl_.outofpvs_entity_updates_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t& CSVCMsg_PacketEntities::_internal_outofpvs_entity_updates() const {
  const ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* p = _impl_.outofpvs_entity_updates_;
  return p != nullptr ? *p : reinterpret_cast<const ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t&>(
      ::_CSVCMsg_PacketEntities_outofpvs_entity_updates_t_default_instance_);
}
inline const ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t& CSVCMsg_PacketEntities::outofpvs_entity_updates() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.outofpvs_entity_updates)
  return _internal_outofpvs_entity_updates();
}
inline void CSVCMsg_PacketEntities::unsafe_arena_set_allocated_outofpvs_entity_updates(
    ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* outofpvs_entity_updates) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.outofpvs_entity_updates_);
  }
  _impl_.outofpvs_entity_updates_ = outofpvs_entity_updates;
  if (outofpvs_entity_updates) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CSVCMsg_PacketEntities.outofpvs_entity_updates)
}
inline ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* CSVCMsg_PacketEntities::release_outofpvs_entity_updates() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* temp = _impl_.outofpvs_entity_updates_;
  _impl_.outofpvs_entity_updates_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* CSVCMsg_PacketEntities::unsafe_arena_release_outofpvs_entity_updates() {
  // @@protoc_insertion_point(field_release:CSVCMsg_PacketEntities.outofpvs_entity_updates)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* temp = _impl_.outofpvs_entity_updates_;
  _impl_.outofpvs_entity_updates_ = nullptr;
  return temp;
}
inline ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* CSVCMsg_PacketEntities::_internal_mutable_outofpvs_entity_updates() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.outofpvs_entity_updates_ == nullptr) {
    auto* p = CreateMaybeMessage<::CSVCMsg_PacketEntities_outofpvs_entity_updates_t>(GetArenaForAllocation());
    _impl_.outofpvs_entity_updates_ = p;
  }
  return _impl_.outofpvs_entity_updates_;
}
inline ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* CSVCMsg_PacketEntities::mutable_outofpvs_entity_updates() {
  ::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* _msg = _internal_mutable_outofpvs_entity_updates();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_PacketEntities.outofpvs_entity_updates)
  return _msg;
}
inline void CSVCMsg_PacketEntities::set_allocated_outofpvs_entity_updates(::CSVCMsg_PacketEntities_outofpvs_entity_updates_t* outofpvs_entity_updates) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.outofpvs_entity_updates_;
  }
  if (outofpvs_entity_updates) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(outofpvs_entity_updates);
    if (message_arena != submessage_arena) {
      outofpvs_entity_updates = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, outofpvs_entity_updates, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.outofpvs_entity_updates_ = outofpvs_entity_updates;
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_PacketEntities.outofpvs_entity_updates)
}

// optional bytes dev_padding = 999;
inline bool CSVCMsg_PacketEntities::_internal_has_dev_padding() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_PacketEntities::has_dev_padding() const {
  return _internal_has_dev_padding();
}
inline void CSVCMsg_PacketEntities::clear_dev_padding() {
  _impl_.dev_padding_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CSVCMsg_PacketEntities::dev_padding() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketEntities.dev_padding)
  return _internal_dev_padding();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_PacketEntities::set_dev_padding(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.dev_padding_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketEntities.dev_padding)
}
inline std::string* CSVCMsg_PacketEntities::mutable_dev_padding() {
  std::string* _s = _internal_mutable_dev_padding();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_PacketEntities.dev_padding)
  return _s;
}
inline const std::string& CSVCMsg_PacketEntities::_internal_dev_padding() const {
  return _impl_.dev_padding_.Get();
}
inline void CSVCMsg_PacketEntities::_internal_set_dev_padding(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.dev_padding_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_PacketEntities::_internal_mutable_dev_padding() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.dev_padding_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_PacketEntities::release_dev_padding() {
  // @@protoc_insertion_point(field_release:CSVCMsg_PacketEntities.dev_padding)
  if (!_internal_has_dev_padding()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.dev_padding_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dev_padding_.IsDefault()) {
    _impl_.dev_padding_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_PacketEntities::set_allocated_dev_padding(std::string* dev_padding) {
  if (dev_padding != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.dev_padding_.SetAllocated(dev_padding, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dev_padding_.IsDefault()) {
    _impl_.dev_padding_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_PacketEntities.dev_padding)
}

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

// CSVCMsg_TempEntities

// optional bool reliable = 1;
inline bool CSVCMsg_TempEntities::_internal_has_reliable() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_TempEntities::has_reliable() const {
  return _internal_has_reliable();
}
inline void CSVCMsg_TempEntities::clear_reliable() {
  _impl_.reliable_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CSVCMsg_TempEntities::_internal_reliable() const {
  return _impl_.reliable_;
}
inline bool CSVCMsg_TempEntities::reliable() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_TempEntities.reliable)
  return _internal_reliable();
}
inline void CSVCMsg_TempEntities::_internal_set_reliable(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.reliable_ = value;
}
inline void CSVCMsg_TempEntities::set_reliable(bool value) {
  _internal_set_reliable(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_TempEntities.reliable)
}

// optional int32 num_entries = 2;
inline bool CSVCMsg_TempEntities::_internal_has_num_entries() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_TempEntities::has_num_entries() const {
  return _internal_has_num_entries();
}
inline void CSVCMsg_TempEntities::clear_num_entries() {
  _impl_.num_entries_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CSVCMsg_TempEntities::_internal_num_entries() const {
  return _impl_.num_entries_;
}
inline int32_t CSVCMsg_TempEntities::num_entries() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_TempEntities.num_entries)
  return _internal_num_entries();
}
inline void CSVCMsg_TempEntities::_internal_set_num_entries(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.num_entries_ = value;
}
inline void CSVCMsg_TempEntities::set_num_entries(int32_t value) {
  _internal_set_num_entries(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_TempEntities.num_entries)
}

// optional bytes entity_data = 3;
inline bool CSVCMsg_TempEntities::_internal_has_entity_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_TempEntities::has_entity_data() const {
  return _internal_has_entity_data();
}
inline void CSVCMsg_TempEntities::clear_entity_data() {
  _impl_.entity_data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_TempEntities::entity_data() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_TempEntities.entity_data)
  return _internal_entity_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_TempEntities::set_entity_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.entity_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_TempEntities.entity_data)
}
inline std::string* CSVCMsg_TempEntities::mutable_entity_data() {
  std::string* _s = _internal_mutable_entity_data();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_TempEntities.entity_data)
  return _s;
}
inline const std::string& CSVCMsg_TempEntities::_internal_entity_data() const {
  return _impl_.entity_data_.Get();
}
inline void CSVCMsg_TempEntities::_internal_set_entity_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.entity_data_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_TempEntities::_internal_mutable_entity_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.entity_data_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_TempEntities::release_entity_data() {
  // @@protoc_insertion_point(field_release:CSVCMsg_TempEntities.entity_data)
  if (!_internal_has_entity_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.entity_data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.entity_data_.IsDefault()) {
    _impl_.entity_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_TempEntities::set_allocated_entity_data(std::string* entity_data) {
  if (entity_data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.entity_data_.SetAllocated(entity_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.entity_data_.IsDefault()) {
    _impl_.entity_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_TempEntities.entity_data)
}

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

// CSVCMsg_CreateStringTable

// optional string name = 1;
inline bool CSVCMsg_CreateStringTable::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_CreateStringTable::has_name() const {
  return _internal_has_name();
}
inline void CSVCMsg_CreateStringTable::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_CreateStringTable::name() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_CreateStringTable.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_CreateStringTable::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_CreateStringTable.name)
}
inline std::string* CSVCMsg_CreateStringTable::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_CreateStringTable.name)
  return _s;
}
inline const std::string& CSVCMsg_CreateStringTable::_internal_name() const {
  return _impl_.name_.Get();
}
inline void CSVCMsg_CreateStringTable::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_CreateStringTable::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_CreateStringTable::release_name() {
  // @@protoc_insertion_point(field_release:CSVCMsg_CreateStringTable.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_CreateStringTable::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_CreateStringTable.name)
}

// optional int32 num_entries = 2;
inline bool CSVCMsg_CreateStringTable::_internal_has_num_entries() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_CreateStringTable::has_num_entries() const {
  return _internal_has_num_entries();
}
inline void CSVCMsg_CreateStringTable::clear_num_entries() {
  _impl_.num_entries_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CSVCMsg_CreateStringTable::_internal_num_entries() const {
  return _impl_.num_entries_;
}
inline int32_t CSVCMsg_CreateStringTable::num_entries() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_CreateStringTable.num_entries)
  return _internal_num_entries();
}
inline void CSVCMsg_CreateStringTable::_internal_set_num_entries(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.num_entries_ = value;
}
inline void CSVCMsg_CreateStringTable::set_num_entries(int32_t value) {
  _internal_set_num_entries(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_CreateStringTable.num_entries)
}

// optional bool user_data_fixed_size = 3;
inline bool CSVCMsg_CreateStringTable::_internal_has_user_data_fixed_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CSVCMsg_CreateStringTable::has_user_data_fixed_size() const {
  return _internal_has_user_data_fixed_size();
}
inline void CSVCMsg_CreateStringTable::clear_user_data_fixed_size() {
  _impl_.user_data_fixed_size_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool CSVCMsg_CreateStringTable::_internal_user_data_fixed_size() const {
  return _impl_.user_data_fixed_size_;
}
inline bool CSVCMsg_CreateStringTable::user_data_fixed_size() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_CreateStringTable.user_data_fixed_size)
  return _internal_user_data_fixed_size();
}
inline void CSVCMsg_CreateStringTable::_internal_set_user_data_fixed_size(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.user_data_fixed_size_ = value;
}
inline void CSVCMsg_CreateStringTable::set_user_data_fixed_size(bool value) {
  _internal_set_user_data_fixed_size(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_CreateStringTable.user_data_fixed_size)
}

// optional int32 user_data_size = 4;
inline bool CSVCMsg_CreateStringTable::_internal_has_user_data_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSVCMsg_CreateStringTable::has_user_data_size() const {
  return _internal_has_user_data_size();
}
inline void CSVCMsg_CreateStringTable::clear_user_data_size() {
  _impl_.user_data_size_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CSVCMsg_CreateStringTable::_internal_user_data_size() const {
  return _impl_.user_data_size_;
}
inline int32_t CSVCMsg_CreateStringTable::user_data_size() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_CreateStringTable.user_data_size)
  return _internal_user_data_size();
}
inline void CSVCMsg_CreateStringTable::_internal_set_user_data_size(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.user_data_size_ = value;
}
inline void CSVCMsg_CreateStringTable::set_user_data_size(int32_t value) {
  _internal_set_user_data_size(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_CreateStringTable.user_data_size)
}

// optional int32 user_data_size_bits = 5;
inline bool CSVCMsg_CreateStringTable::_internal_has_user_data_size_bits() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSVCMsg_CreateStringTable::has_user_data_size_bits() const {
  return _internal_has_user_data_size_bits();
}
inline void CSVCMsg_CreateStringTable::clear_user_data_size_bits() {
  _impl_.user_data_size_bits_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CSVCMsg_CreateStringTable::_internal_user_data_size_bits() const {
  return _impl_.user_data_size_bits_;
}
inline int32_t CSVCMsg_CreateStringTable::user_data_size_bits() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_CreateStringTable.user_data_size_bits)
  return _internal_user_data_size_bits();
}
inline void CSVCMsg_CreateStringTable::_internal_set_user_data_size_bits(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.user_data_size_bits_ = value;
}
inline void CSVCMsg_CreateStringTable::set_user_data_size_bits(int32_t value) {
  _internal_set_user_data_size_bits(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_CreateStringTable.user_data_size_bits)
}

// optional int32 flags = 6;
inline bool CSVCMsg_CreateStringTable::_internal_has_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CSVCMsg_CreateStringTable::has_flags() const {
  return _internal_has_flags();
}
inline void CSVCMsg_CreateStringTable::clear_flags() {
  _impl_.flags_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CSVCMsg_CreateStringTable::_internal_flags() const {
  return _impl_.flags_;
}
inline int32_t CSVCMsg_CreateStringTable::flags() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_CreateStringTable.flags)
  return _internal_flags();
}
inline void CSVCMsg_CreateStringTable::_internal_set_flags(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.flags_ = value;
}
inline void CSVCMsg_CreateStringTable::set_flags(int32_t value) {
  _internal_set_flags(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_CreateStringTable.flags)
}

// optional bytes string_data = 7;
inline bool CSVCMsg_CreateStringTable::_internal_has_string_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_CreateStringTable::has_string_data() const {
  return _internal_has_string_data();
}
inline void CSVCMsg_CreateStringTable::clear_string_data() {
  _impl_.string_data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CSVCMsg_CreateStringTable::string_data() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_CreateStringTable.string_data)
  return _internal_string_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_CreateStringTable::set_string_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.string_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_CreateStringTable.string_data)
}
inline std::string* CSVCMsg_CreateStringTable::mutable_string_data() {
  std::string* _s = _internal_mutable_string_data();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_CreateStringTable.string_data)
  return _s;
}
inline const std::string& CSVCMsg_CreateStringTable::_internal_string_data() const {
  return _impl_.string_data_.Get();
}
inline void CSVCMsg_CreateStringTable::_internal_set_string_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.string_data_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_CreateStringTable::_internal_mutable_string_data() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.string_data_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_CreateStringTable::release_string_data() {
  // @@protoc_insertion_point(field_release:CSVCMsg_CreateStringTable.string_data)
  if (!_internal_has_string_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.string_data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.string_data_.IsDefault()) {
    _impl_.string_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_CreateStringTable::set_allocated_string_data(std::string* string_data) {
  if (string_data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.string_data_.SetAllocated(string_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.string_data_.IsDefault()) {
    _impl_.string_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_CreateStringTable.string_data)
}

// optional int32 uncompressed_size = 8;
inline bool CSVCMsg_CreateStringTable::_internal_has_uncompressed_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CSVCMsg_CreateStringTable::has_uncompressed_size() const {
  return _internal_has_uncompressed_size();
}
inline void CSVCMsg_CreateStringTable::clear_uncompressed_size() {
  _impl_.uncompressed_size_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t CSVCMsg_CreateStringTable::_internal_uncompressed_size() const {
  return _impl_.uncompressed_size_;
}
inline int32_t CSVCMsg_CreateStringTable::uncompressed_size() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_CreateStringTable.uncompressed_size)
  return _internal_uncompressed_size();
}
inline void CSVCMsg_CreateStringTable::_internal_set_uncompressed_size(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.uncompressed_size_ = value;
}
inline void CSVCMsg_CreateStringTable::set_uncompressed_size(int32_t value) {
  _internal_set_uncompressed_size(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_CreateStringTable.uncompressed_size)
}

// optional bool data_compressed = 9;
inline bool CSVCMsg_CreateStringTable::_internal_has_data_compressed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CSVCMsg_CreateStringTable::has_data_compressed() const {
  return _internal_has_data_compressed();
}
inline void CSVCMsg_CreateStringTable::clear_data_compressed() {
  _impl_.data_compressed_ = false;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline bool CSVCMsg_CreateStringTable::_internal_data_compressed() const {
  return _impl_.data_compressed_;
}
inline bool CSVCMsg_CreateStringTable::data_compressed() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_CreateStringTable.data_compressed)
  return _internal_data_compressed();
}
inline void CSVCMsg_CreateStringTable::_internal_set_data_compressed(bool value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.data_compressed_ = value;
}
inline void CSVCMsg_CreateStringTable::set_data_compressed(bool value) {
  _internal_set_data_compressed(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_CreateStringTable.data_compressed)
}

// optional bool using_varint_bitcounts = 10;
inline bool CSVCMsg_CreateStringTable::_internal_has_using_varint_bitcounts() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CSVCMsg_CreateStringTable::has_using_varint_bitcounts() const {
  return _internal_has_using_varint_bitcounts();
}
inline void CSVCMsg_CreateStringTable::clear_using_varint_bitcounts() {
  _impl_.using_varint_bitcounts_ = false;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline bool CSVCMsg_CreateStringTable::_internal_using_varint_bitcounts() const {
  return _impl_.using_varint_bitcounts_;
}
inline bool CSVCMsg_CreateStringTable::using_varint_bitcounts() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_CreateStringTable.using_varint_bitcounts)
  return _internal_using_varint_bitcounts();
}
inline void CSVCMsg_CreateStringTable::_internal_set_using_varint_bitcounts(bool value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.using_varint_bitcounts_ = value;
}
inline void CSVCMsg_CreateStringTable::set_using_varint_bitcounts(bool value) {
  _internal_set_using_varint_bitcounts(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_CreateStringTable.using_varint_bitcounts)
}

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

// CSVCMsg_UpdateStringTable

// optional int32 table_id = 1;
inline bool CSVCMsg_UpdateStringTable::_internal_has_table_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_UpdateStringTable::has_table_id() const {
  return _internal_has_table_id();
}
inline void CSVCMsg_UpdateStringTable::clear_table_id() {
  _impl_.table_id_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_UpdateStringTable::_internal_table_id() const {
  return _impl_.table_id_;
}
inline int32_t CSVCMsg_UpdateStringTable::table_id() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_UpdateStringTable.table_id)
  return _internal_table_id();
}
inline void CSVCMsg_UpdateStringTable::_internal_set_table_id(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.table_id_ = value;
}
inline void CSVCMsg_UpdateStringTable::set_table_id(int32_t value) {
  _internal_set_table_id(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_UpdateStringTable.table_id)
}

// optional int32 num_changed_entries = 2;
inline bool CSVCMsg_UpdateStringTable::_internal_has_num_changed_entries() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_UpdateStringTable::has_num_changed_entries() const {
  return _internal_has_num_changed_entries();
}
inline void CSVCMsg_UpdateStringTable::clear_num_changed_entries() {
  _impl_.num_changed_entries_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CSVCMsg_UpdateStringTable::_internal_num_changed_entries() const {
  return _impl_.num_changed_entries_;
}
inline int32_t CSVCMsg_UpdateStringTable::num_changed_entries() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_UpdateStringTable.num_changed_entries)
  return _internal_num_changed_entries();
}
inline void CSVCMsg_UpdateStringTable::_internal_set_num_changed_entries(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.num_changed_entries_ = value;
}
inline void CSVCMsg_UpdateStringTable::set_num_changed_entries(int32_t value) {
  _internal_set_num_changed_entries(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_UpdateStringTable.num_changed_entries)
}

// optional bytes string_data = 3;
inline bool CSVCMsg_UpdateStringTable::_internal_has_string_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_UpdateStringTable::has_string_data() const {
  return _internal_has_string_data();
}
inline void CSVCMsg_UpdateStringTable::clear_string_data() {
  _impl_.string_data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_UpdateStringTable::string_data() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_UpdateStringTable.string_data)
  return _internal_string_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_UpdateStringTable::set_string_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.string_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_UpdateStringTable.string_data)
}
inline std::string* CSVCMsg_UpdateStringTable::mutable_string_data() {
  std::string* _s = _internal_mutable_string_data();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_UpdateStringTable.string_data)
  return _s;
}
inline const std::string& CSVCMsg_UpdateStringTable::_internal_string_data() const {
  return _impl_.string_data_.Get();
}
inline void CSVCMsg_UpdateStringTable::_internal_set_string_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.string_data_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_UpdateStringTable::_internal_mutable_string_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.string_data_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_UpdateStringTable::release_string_data() {
  // @@protoc_insertion_point(field_release:CSVCMsg_UpdateStringTable.string_data)
  if (!_internal_has_string_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.string_data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.string_data_.IsDefault()) {
    _impl_.string_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_UpdateStringTable::set_allocated_string_data(std::string* string_data) {
  if (string_data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.string_data_.SetAllocated(string_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.string_data_.IsDefault()) {
    _impl_.string_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_UpdateStringTable.string_data)
}

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

// CSVCMsg_VoiceData

// optional .CMsgVoiceAudio audio = 1;
inline bool CSVCMsg_VoiceData::_internal_has_audio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.audio_ != nullptr);
  return value;
}
inline bool CSVCMsg_VoiceData::has_audio() const {
  return _internal_has_audio();
}
inline void CSVCMsg_VoiceData::clear_audio() {
  if (_impl_.audio_ != nullptr) _impl_.audio_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsgVoiceAudio& CSVCMsg_VoiceData::_internal_audio() const {
  const ::CMsgVoiceAudio* p = _impl_.audio_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVoiceAudio&>(
      ::_CMsgVoiceAudio_default_instance_);
}
inline const ::CMsgVoiceAudio& CSVCMsg_VoiceData::audio() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_VoiceData.audio)
  return _internal_audio();
}
inline void CSVCMsg_VoiceData::unsafe_arena_set_allocated_audio(
    ::CMsgVoiceAudio* audio) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.audio_);
  }
  _impl_.audio_ = audio;
  if (audio) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CSVCMsg_VoiceData.audio)
}
inline ::CMsgVoiceAudio* CSVCMsg_VoiceData::release_audio() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVoiceAudio* temp = _impl_.audio_;
  _impl_.audio_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVoiceAudio* CSVCMsg_VoiceData::unsafe_arena_release_audio() {
  // @@protoc_insertion_point(field_release:CSVCMsg_VoiceData.audio)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVoiceAudio* temp = _impl_.audio_;
  _impl_.audio_ = nullptr;
  return temp;
}
inline ::CMsgVoiceAudio* CSVCMsg_VoiceData::_internal_mutable_audio() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.audio_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVoiceAudio>(GetArenaForAllocation());
    _impl_.audio_ = p;
  }
  return _impl_.audio_;
}
inline ::CMsgVoiceAudio* CSVCMsg_VoiceData::mutable_audio() {
  ::CMsgVoiceAudio* _msg = _internal_mutable_audio();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_VoiceData.audio)
  return _msg;
}
inline void CSVCMsg_VoiceData::set_allocated_audio(::CMsgVoiceAudio* audio) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.audio_;
  }
  if (audio) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(audio);
    if (message_arena != submessage_arena) {
      audio = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, audio, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.audio_ = audio;
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_VoiceData.audio)
}

// optional int32 client = 2 [default = -1];
inline bool CSVCMsg_VoiceData::_internal_has_client() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CSVCMsg_VoiceData::has_client() const {
  return _internal_has_client();
}
inline void CSVCMsg_VoiceData::clear_client() {
  _impl_.client_ = -1;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t CSVCMsg_VoiceData::_internal_client() const {
  return _impl_.client_;
}
inline int32_t CSVCMsg_VoiceData::client() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_VoiceData.client)
  return _internal_client();
}
inline void CSVCMsg_VoiceData::_internal_set_client(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.client_ = value;
}
inline void CSVCMsg_VoiceData::set_client(int32_t value) {
  _internal_set_client(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_VoiceData.client)
}

// optional bool proximity = 3;
inline bool CSVCMsg_VoiceData::_internal_has_proximity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_VoiceData::has_proximity() const {
  return _internal_has_proximity();
}
inline void CSVCMsg_VoiceData::clear_proximity() {
  _impl_.proximity_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CSVCMsg_VoiceData::_internal_proximity() const {
  return _impl_.proximity_;
}
inline bool CSVCMsg_VoiceData::proximity() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_VoiceData.proximity)
  return _internal_proximity();
}
inline void CSVCMsg_VoiceData::_internal_set_proximity(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.proximity_ = value;
}
inline void CSVCMsg_VoiceData::set_proximity(bool value) {
  _internal_set_proximity(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_VoiceData.proximity)
}

// optional fixed64 xuid = 4;
inline bool CSVCMsg_VoiceData::_internal_has_xuid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_VoiceData::has_xuid() const {
  return _internal_has_xuid();
}
inline void CSVCMsg_VoiceData::clear_xuid() {
  _impl_.xuid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CSVCMsg_VoiceData::_internal_xuid() const {
  return _impl_.xuid_;
}
inline uint64_t CSVCMsg_VoiceData::xuid() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_VoiceData.xuid)
  return _internal_xuid();
}
inline void CSVCMsg_VoiceData::_internal_set_xuid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.xuid_ = value;
}
inline void CSVCMsg_VoiceData::set_xuid(uint64_t value) {
  _internal_set_xuid(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_VoiceData.xuid)
}

// optional int32 audible_mask = 5;
inline bool CSVCMsg_VoiceData::_internal_has_audible_mask() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSVCMsg_VoiceData::has_audible_mask() const {
  return _internal_has_audible_mask();
}
inline void CSVCMsg_VoiceData::clear_audible_mask() {
  _impl_.audible_mask_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CSVCMsg_VoiceData::_internal_audible_mask() const {
  return _impl_.audible_mask_;
}
inline int32_t CSVCMsg_VoiceData::audible_mask() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_VoiceData.audible_mask)
  return _internal_audible_mask();
}
inline void CSVCMsg_VoiceData::_internal_set_audible_mask(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.audible_mask_ = value;
}
inline void CSVCMsg_VoiceData::set_audible_mask(int32_t value) {
  _internal_set_audible_mask(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_VoiceData.audible_mask)
}

// optional uint32 tick = 6;
inline bool CSVCMsg_VoiceData::_internal_has_tick() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSVCMsg_VoiceData::has_tick() const {
  return _internal_has_tick();
}
inline void CSVCMsg_VoiceData::clear_tick() {
  _impl_.tick_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CSVCMsg_VoiceData::_internal_tick() const {
  return _impl_.tick_;
}
inline uint32_t CSVCMsg_VoiceData::tick() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_VoiceData.tick)
  return _internal_tick();
}
inline void CSVCMsg_VoiceData::_internal_set_tick(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.tick_ = value;
}
inline void CSVCMsg_VoiceData::set_tick(uint32_t value) {
  _internal_set_tick(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_VoiceData.tick)
}

// optional int32 passthrough = 7;
inline bool CSVCMsg_VoiceData::_internal_has_passthrough() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CSVCMsg_VoiceData::has_passthrough() const {
  return _internal_has_passthrough();
}
inline void CSVCMsg_VoiceData::clear_passthrough() {
  _impl_.passthrough_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CSVCMsg_VoiceData::_internal_passthrough() const {
  return _impl_.passthrough_;
}
inline int32_t CSVCMsg_VoiceData::passthrough() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_VoiceData.passthrough)
  return _internal_passthrough();
}
inline void CSVCMsg_VoiceData::_internal_set_passthrough(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.passthrough_ = value;
}
inline void CSVCMsg_VoiceData::set_passthrough(int32_t value) {
  _internal_set_passthrough(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_VoiceData.passthrough)
}

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

// CSVCMsg_PacketReliable

// optional int32 tick = 1;
inline bool CSVCMsg_PacketReliable::_internal_has_tick() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_PacketReliable::has_tick() const {
  return _internal_has_tick();
}
inline void CSVCMsg_PacketReliable::clear_tick() {
  _impl_.tick_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CSVCMsg_PacketReliable::_internal_tick() const {
  return _impl_.tick_;
}
inline int32_t CSVCMsg_PacketReliable::tick() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketReliable.tick)
  return _internal_tick();
}
inline void CSVCMsg_PacketReliable::_internal_set_tick(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.tick_ = value;
}
inline void CSVCMsg_PacketReliable::set_tick(int32_t value) {
  _internal_set_tick(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketReliable.tick)
}

// optional int32 messagessize = 2;
inline bool CSVCMsg_PacketReliable::_internal_has_messagessize() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_PacketReliable::has_messagessize() const {
  return _internal_has_messagessize();
}
inline void CSVCMsg_PacketReliable::clear_messagessize() {
  _impl_.messagessize_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_PacketReliable::_internal_messagessize() const {
  return _impl_.messagessize_;
}
inline int32_t CSVCMsg_PacketReliable::messagessize() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketReliable.messagessize)
  return _internal_messagessize();
}
inline void CSVCMsg_PacketReliable::_internal_set_messagessize(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.messagessize_ = value;
}
inline void CSVCMsg_PacketReliable::set_messagessize(int32_t value) {
  _internal_set_messagessize(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketReliable.messagessize)
}

// optional bool state = 3;
inline bool CSVCMsg_PacketReliable::_internal_has_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_PacketReliable::has_state() const {
  return _internal_has_state();
}
inline void CSVCMsg_PacketReliable::clear_state() {
  _impl_.state_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CSVCMsg_PacketReliable::_internal_state() const {
  return _impl_.state_;
}
inline bool CSVCMsg_PacketReliable::state() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PacketReliable.state)
  return _internal_state();
}
inline void CSVCMsg_PacketReliable::_internal_set_state(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.state_ = value;
}
inline void CSVCMsg_PacketReliable::set_state(bool value) {
  _internal_set_state(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_PacketReliable.state)
}

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

// CSVCMsg_FullFrameSplit

// optional int32 tick = 1;
inline bool CSVCMsg_FullFrameSplit::_internal_has_tick() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_FullFrameSplit::has_tick() const {
  return _internal_has_tick();
}
inline void CSVCMsg_FullFrameSplit::clear_tick() {
  _impl_.tick_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_FullFrameSplit::_internal_tick() const {
  return _impl_.tick_;
}
inline int32_t CSVCMsg_FullFrameSplit::tick() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_FullFrameSplit.tick)
  return _internal_tick();
}
inline void CSVCMsg_FullFrameSplit::_internal_set_tick(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.tick_ = value;
}
inline void CSVCMsg_FullFrameSplit::set_tick(int32_t value) {
  _internal_set_tick(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_FullFrameSplit.tick)
}

// optional int32 section = 2;
inline bool CSVCMsg_FullFrameSplit::_internal_has_section() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_FullFrameSplit::has_section() const {
  return _internal_has_section();
}
inline void CSVCMsg_FullFrameSplit::clear_section() {
  _impl_.section_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CSVCMsg_FullFrameSplit::_internal_section() const {
  return _impl_.section_;
}
inline int32_t CSVCMsg_FullFrameSplit::section() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_FullFrameSplit.section)
  return _internal_section();
}
inline void CSVCMsg_FullFrameSplit::_internal_set_section(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.section_ = value;
}
inline void CSVCMsg_FullFrameSplit::set_section(int32_t value) {
  _internal_set_section(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_FullFrameSplit.section)
}

// optional int32 total = 3;
inline bool CSVCMsg_FullFrameSplit::_internal_has_total() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSVCMsg_FullFrameSplit::has_total() const {
  return _internal_has_total();
}
inline void CSVCMsg_FullFrameSplit::clear_total() {
  _impl_.total_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CSVCMsg_FullFrameSplit::_internal_total() const {
  return _impl_.total_;
}
inline int32_t CSVCMsg_FullFrameSplit::total() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_FullFrameSplit.total)
  return _internal_total();
}
inline void CSVCMsg_FullFrameSplit::_internal_set_total(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.total_ = value;
}
inline void CSVCMsg_FullFrameSplit::set_total(int32_t value) {
  _internal_set_total(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_FullFrameSplit.total)
}

// optional bytes data = 4;
inline bool CSVCMsg_FullFrameSplit::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_FullFrameSplit::has_data() const {
  return _internal_has_data();
}
inline void CSVCMsg_FullFrameSplit::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_FullFrameSplit::data() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_FullFrameSplit.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_FullFrameSplit::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_FullFrameSplit.data)
}
inline std::string* CSVCMsg_FullFrameSplit::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_FullFrameSplit.data)
  return _s;
}
inline const std::string& CSVCMsg_FullFrameSplit::_internal_data() const {
  return _impl_.data_.Get();
}
inline void CSVCMsg_FullFrameSplit::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_FullFrameSplit::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_FullFrameSplit::release_data() {
  // @@protoc_insertion_point(field_release:CSVCMsg_FullFrameSplit.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_FullFrameSplit::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_FullFrameSplit.data)
}

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

// CSVCMsg_HLTVStatus

// optional string master = 1;
inline bool CSVCMsg_HLTVStatus::_internal_has_master() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_HLTVStatus::has_master() const {
  return _internal_has_master();
}
inline void CSVCMsg_HLTVStatus::clear_master() {
  _impl_.master_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_HLTVStatus::master() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_HLTVStatus.master)
  return _internal_master();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_HLTVStatus::set_master(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.master_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_HLTVStatus.master)
}
inline std::string* CSVCMsg_HLTVStatus::mutable_master() {
  std::string* _s = _internal_mutable_master();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_HLTVStatus.master)
  return _s;
}
inline const std::string& CSVCMsg_HLTVStatus::_internal_master() const {
  return _impl_.master_.Get();
}
inline void CSVCMsg_HLTVStatus::_internal_set_master(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.master_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_HLTVStatus::_internal_mutable_master() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.master_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_HLTVStatus::release_master() {
  // @@protoc_insertion_point(field_release:CSVCMsg_HLTVStatus.master)
  if (!_internal_has_master()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.master_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.master_.IsDefault()) {
    _impl_.master_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_HLTVStatus::set_allocated_master(std::string* master) {
  if (master != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.master_.SetAllocated(master, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.master_.IsDefault()) {
    _impl_.master_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_HLTVStatus.master)
}

// optional int32 clients = 2;
inline bool CSVCMsg_HLTVStatus::_internal_has_clients() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_HLTVStatus::has_clients() const {
  return _internal_has_clients();
}
inline void CSVCMsg_HLTVStatus::clear_clients() {
  _impl_.clients_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_HLTVStatus::_internal_clients() const {
  return _impl_.clients_;
}
inline int32_t CSVCMsg_HLTVStatus::clients() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_HLTVStatus.clients)
  return _internal_clients();
}
inline void CSVCMsg_HLTVStatus::_internal_set_clients(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.clients_ = value;
}
inline void CSVCMsg_HLTVStatus::set_clients(int32_t value) {
  _internal_set_clients(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_HLTVStatus.clients)
}

// optional int32 slots = 3;
inline bool CSVCMsg_HLTVStatus::_internal_has_slots() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_HLTVStatus::has_slots() const {
  return _internal_has_slots();
}
inline void CSVCMsg_HLTVStatus::clear_slots() {
  _impl_.slots_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CSVCMsg_HLTVStatus::_internal_slots() const {
  return _impl_.slots_;
}
inline int32_t CSVCMsg_HLTVStatus::slots() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_HLTVStatus.slots)
  return _internal_slots();
}
inline void CSVCMsg_HLTVStatus::_internal_set_slots(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.slots_ = value;
}
inline void CSVCMsg_HLTVStatus::set_slots(int32_t value) {
  _internal_set_slots(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_HLTVStatus.slots)
}

// optional int32 proxies = 4;
inline bool CSVCMsg_HLTVStatus::_internal_has_proxies() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSVCMsg_HLTVStatus::has_proxies() const {
  return _internal_has_proxies();
}
inline void CSVCMsg_HLTVStatus::clear_proxies() {
  _impl_.proxies_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CSVCMsg_HLTVStatus::_internal_proxies() const {
  return _impl_.proxies_;
}
inline int32_t CSVCMsg_HLTVStatus::proxies() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_HLTVStatus.proxies)
  return _internal_proxies();
}
inline void CSVCMsg_HLTVStatus::_internal_set_proxies(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.proxies_ = value;
}
inline void CSVCMsg_HLTVStatus::set_proxies(int32_t value) {
  _internal_set_proxies(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_HLTVStatus.proxies)
}

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

// CSVCMsg_ServerSteamID

// optional uint64 steam_id = 1;
inline bool CSVCMsg_ServerSteamID::_internal_has_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_ServerSteamID::has_steam_id() const {
  return _internal_has_steam_id();
}
inline void CSVCMsg_ServerSteamID::clear_steam_id() {
  _impl_.steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CSVCMsg_ServerSteamID::_internal_steam_id() const {
  return _impl_.steam_id_;
}
inline uint64_t CSVCMsg_ServerSteamID::steam_id() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ServerSteamID.steam_id)
  return _internal_steam_id();
}
inline void CSVCMsg_ServerSteamID::_internal_set_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.steam_id_ = value;
}
inline void CSVCMsg_ServerSteamID::set_steam_id(uint64_t value) {
  _internal_set_steam_id(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_ServerSteamID.steam_id)
}

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

// CSVCMsg_CmdKeyValues

// optional bytes data = 1;
inline bool CSVCMsg_CmdKeyValues::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_CmdKeyValues::has_data() const {
  return _internal_has_data();
}
inline void CSVCMsg_CmdKeyValues::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_CmdKeyValues::data() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_CmdKeyValues.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_CmdKeyValues::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_CmdKeyValues.data)
}
inline std::string* CSVCMsg_CmdKeyValues::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_CmdKeyValues.data)
  return _s;
}
inline const std::string& CSVCMsg_CmdKeyValues::_internal_data() const {
  return _impl_.data_.Get();
}
inline void CSVCMsg_CmdKeyValues::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_CmdKeyValues::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_CmdKeyValues::release_data() {
  // @@protoc_insertion_point(field_release:CSVCMsg_CmdKeyValues.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_CmdKeyValues::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_CmdKeyValues.data)
}

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

// CSVCMsg_RconServerDetails

// optional bytes token = 1;
inline bool CSVCMsg_RconServerDetails::_internal_has_token() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_RconServerDetails::has_token() const {
  return _internal_has_token();
}
inline void CSVCMsg_RconServerDetails::clear_token() {
  _impl_.token_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_RconServerDetails::token() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_RconServerDetails.token)
  return _internal_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_RconServerDetails::set_token(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.token_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_RconServerDetails.token)
}
inline std::string* CSVCMsg_RconServerDetails::mutable_token() {
  std::string* _s = _internal_mutable_token();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_RconServerDetails.token)
  return _s;
}
inline const std::string& CSVCMsg_RconServerDetails::_internal_token() const {
  return _impl_.token_.Get();
}
inline void CSVCMsg_RconServerDetails::_internal_set_token(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.token_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_RconServerDetails::_internal_mutable_token() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.token_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_RconServerDetails::release_token() {
  // @@protoc_insertion_point(field_release:CSVCMsg_RconServerDetails.token)
  if (!_internal_has_token()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.token_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.token_.IsDefault()) {
    _impl_.token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_RconServerDetails::set_allocated_token(std::string* token) {
  if (token != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.token_.SetAllocated(token, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.token_.IsDefault()) {
    _impl_.token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_RconServerDetails.token)
}

// optional string details = 2;
inline bool CSVCMsg_RconServerDetails::_internal_has_details() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_RconServerDetails::has_details() const {
  return _internal_has_details();
}
inline void CSVCMsg_RconServerDetails::clear_details() {
  _impl_.details_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CSVCMsg_RconServerDetails::details() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_RconServerDetails.details)
  return _internal_details();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_RconServerDetails::set_details(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.details_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_RconServerDetails.details)
}
inline std::string* CSVCMsg_RconServerDetails::mutable_details() {
  std::string* _s = _internal_mutable_details();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_RconServerDetails.details)
  return _s;
}
inline const std::string& CSVCMsg_RconServerDetails::_internal_details() const {
  return _impl_.details_.Get();
}
inline void CSVCMsg_RconServerDetails::_internal_set_details(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.details_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_RconServerDetails::_internal_mutable_details() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.details_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_RconServerDetails::release_details() {
  // @@protoc_insertion_point(field_release:CSVCMsg_RconServerDetails.details)
  if (!_internal_has_details()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.details_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.details_.IsDefault()) {
    _impl_.details_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_RconServerDetails::set_allocated_details(std::string* details) {
  if (details != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.details_.SetAllocated(details, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.details_.IsDefault()) {
    _impl_.details_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_RconServerDetails.details)
}

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

// CMsgIPCAddress

// optional fixed64 computer_guid = 1;
inline bool CMsgIPCAddress::_internal_has_computer_guid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgIPCAddress::has_computer_guid() const {
  return _internal_has_computer_guid();
}
inline void CMsgIPCAddress::clear_computer_guid() {
  _impl_.computer_guid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgIPCAddress::_internal_computer_guid() const {
  return _impl_.computer_guid_;
}
inline uint64_t CMsgIPCAddress::computer_guid() const {
  // @@protoc_insertion_point(field_get:CMsgIPCAddress.computer_guid)
  return _internal_computer_guid();
}
inline void CMsgIPCAddress::_internal_set_computer_guid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.computer_guid_ = value;
}
inline void CMsgIPCAddress::set_computer_guid(uint64_t value) {
  _internal_set_computer_guid(value);
  // @@protoc_insertion_point(field_set:CMsgIPCAddress.computer_guid)
}

// optional uint32 process_id = 2;
inline bool CMsgIPCAddress::_internal_has_process_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgIPCAddress::has_process_id() const {
  return _internal_has_process_id();
}
inline void CMsgIPCAddress::clear_process_id() {
  _impl_.process_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgIPCAddress::_internal_process_id() const {
  return _impl_.process_id_;
}
inline uint32_t CMsgIPCAddress::process_id() const {
  // @@protoc_insertion_point(field_get:CMsgIPCAddress.process_id)
  return _internal_process_id();
}
inline void CMsgIPCAddress::_internal_set_process_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.process_id_ = value;
}
inline void CMsgIPCAddress::set_process_id(uint32_t value) {
  _internal_set_process_id(value);
  // @@protoc_insertion_point(field_set:CMsgIPCAddress.process_id)
}

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

// CMsgServerPeer

// optional int32 player_slot = 1 [default = -1];
inline bool CMsgServerPeer::_internal_has_player_slot() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgServerPeer::has_player_slot() const {
  return _internal_has_player_slot();
}
inline void CMsgServerPeer::clear_player_slot() {
  _impl_.player_slot_ = -1;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CMsgServerPeer::_internal_player_slot() const {
  return _impl_.player_slot_;
}
inline int32_t CMsgServerPeer::player_slot() const {
  // @@protoc_insertion_point(field_get:CMsgServerPeer.player_slot)
  return _internal_player_slot();
}
inline void CMsgServerPeer::_internal_set_player_slot(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.player_slot_ = value;
}
inline void CMsgServerPeer::set_player_slot(int32_t value) {
  _internal_set_player_slot(value);
  // @@protoc_insertion_point(field_set:CMsgServerPeer.player_slot)
}

// optional fixed64 steamid = 2;
inline bool CMsgServerPeer::_internal_has_steamid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgServerPeer::has_steamid() const {
  return _internal_has_steamid();
}
inline void CMsgServerPeer::clear_steamid() {
  _impl_.steamid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgServerPeer::_internal_steamid() const {
  return _impl_.steamid_;
}
inline uint64_t CMsgServerPeer::steamid() const {
  // @@protoc_insertion_point(field_get:CMsgServerPeer.steamid)
  return _internal_steamid();
}
inline void CMsgServerPeer::_internal_set_steamid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.steamid_ = value;
}
inline void CMsgServerPeer::set_steamid(uint64_t value) {
  _internal_set_steamid(value);
  // @@protoc_insertion_point(field_set:CMsgServerPeer.steamid)
}

// optional .CMsgIPCAddress ipc = 3;
inline bool CMsgServerPeer::_internal_has_ipc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.ipc_ != nullptr);
  return value;
}
inline bool CMsgServerPeer::has_ipc() const {
  return _internal_has_ipc();
}
inline void CMsgServerPeer::clear_ipc() {
  if (_impl_.ipc_ != nullptr) _impl_.ipc_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsgIPCAddress& CMsgServerPeer::_internal_ipc() const {
  const ::CMsgIPCAddress* p = _impl_.ipc_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgIPCAddress&>(
      ::_CMsgIPCAddress_default_instance_);
}
inline const ::CMsgIPCAddress& CMsgServerPeer::ipc() const {
  // @@protoc_insertion_point(field_get:CMsgServerPeer.ipc)
  return _internal_ipc();
}
inline void CMsgServerPeer::unsafe_arena_set_allocated_ipc(
    ::CMsgIPCAddress* ipc) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ipc_);
  }
  _impl_.ipc_ = ipc;
  if (ipc) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgServerPeer.ipc)
}
inline ::CMsgIPCAddress* CMsgServerPeer::release_ipc() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgIPCAddress* temp = _impl_.ipc_;
  _impl_.ipc_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgIPCAddress* CMsgServerPeer::unsafe_arena_release_ipc() {
  // @@protoc_insertion_point(field_release:CMsgServerPeer.ipc)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgIPCAddress* temp = _impl_.ipc_;
  _impl_.ipc_ = nullptr;
  return temp;
}
inline ::CMsgIPCAddress* CMsgServerPeer::_internal_mutable_ipc() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.ipc_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgIPCAddress>(GetArenaForAllocation());
    _impl_.ipc_ = p;
  }
  return _impl_.ipc_;
}
inline ::CMsgIPCAddress* CMsgServerPeer::mutable_ipc() {
  ::CMsgIPCAddress* _msg = _internal_mutable_ipc();
  // @@protoc_insertion_point(field_mutable:CMsgServerPeer.ipc)
  return _msg;
}
inline void CMsgServerPeer::set_allocated_ipc(::CMsgIPCAddress* ipc) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.ipc_;
  }
  if (ipc) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ipc);
    if (message_arena != submessage_arena) {
      ipc = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ipc, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.ipc_ = ipc;
  // @@protoc_insertion_point(field_set_allocated:CMsgServerPeer.ipc)
}

// optional bool they_hear_you = 4;
inline bool CMsgServerPeer::_internal_has_they_hear_you() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgServerPeer::has_they_hear_you() const {
  return _internal_has_they_hear_you();
}
inline void CMsgServerPeer::clear_they_hear_you() {
  _impl_.they_hear_you_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CMsgServerPeer::_internal_they_hear_you() const {
  return _impl_.they_hear_you_;
}
inline bool CMsgServerPeer::they_hear_you() const {
  // @@protoc_insertion_point(field_get:CMsgServerPeer.they_hear_you)
  return _internal_they_hear_you();
}
inline void CMsgServerPeer::_internal_set_they_hear_you(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.they_hear_you_ = value;
}
inline void CMsgServerPeer::set_they_hear_you(bool value) {
  _internal_set_they_hear_you(value);
  // @@protoc_insertion_point(field_set:CMsgServerPeer.they_hear_you)
}

// optional bool you_hear_them = 5;
inline bool CMsgServerPeer::_internal_has_you_hear_them() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgServerPeer::has_you_hear_them() const {
  return _internal_has_you_hear_them();
}
inline void CMsgServerPeer::clear_you_hear_them() {
  _impl_.you_hear_them_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool CMsgServerPeer::_internal_you_hear_them() const {
  return _impl_.you_hear_them_;
}
inline bool CMsgServerPeer::you_hear_them() const {
  // @@protoc_insertion_point(field_get:CMsgServerPeer.you_hear_them)
  return _internal_you_hear_them();
}
inline void CMsgServerPeer::_internal_set_you_hear_them(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.you_hear_them_ = value;
}
inline void CMsgServerPeer::set_you_hear_them(bool value) {
  _internal_set_you_hear_them(value);
  // @@protoc_insertion_point(field_set:CMsgServerPeer.you_hear_them)
}

// optional bool is_listenserver_host = 6;
inline bool CMsgServerPeer::_internal_has_is_listenserver_host() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgServerPeer::has_is_listenserver_host() const {
  return _internal_has_is_listenserver_host();
}
inline void CMsgServerPeer::clear_is_listenserver_host() {
  _impl_.is_listenserver_host_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool CMsgServerPeer::_internal_is_listenserver_host() const {
  return _impl_.is_listenserver_host_;
}
inline bool CMsgServerPeer::is_listenserver_host() const {
  // @@protoc_insertion_point(field_get:CMsgServerPeer.is_listenserver_host)
  return _internal_is_listenserver_host();
}
inline void CMsgServerPeer::_internal_set_is_listenserver_host(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.is_listenserver_host_ = value;
}
inline void CMsgServerPeer::set_is_listenserver_host(bool value) {
  _internal_set_is_listenserver_host(value);
  // @@protoc_insertion_point(field_set:CMsgServerPeer.is_listenserver_host)
}

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

// CSVCMsg_PeerList

// repeated .CMsgServerPeer peer = 1;
inline int CSVCMsg_PeerList::_internal_peer_size() const {
  return _impl_.peer_.size();
}
inline int CSVCMsg_PeerList::peer_size() const {
  return _internal_peer_size();
}
inline void CSVCMsg_PeerList::clear_peer() {
  _impl_.peer_.Clear();
}
inline ::CMsgServerPeer* CSVCMsg_PeerList::mutable_peer(int index) {
  // @@protoc_insertion_point(field_mutable:CSVCMsg_PeerList.peer)
  return _impl_.peer_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerPeer >*
CSVCMsg_PeerList::mutable_peer() {
  // @@protoc_insertion_point(field_mutable_list:CSVCMsg_PeerList.peer)
  return &_impl_.peer_;
}
inline const ::CMsgServerPeer& CSVCMsg_PeerList::_internal_peer(int index) const {
  return _impl_.peer_.Get(index);
}
inline const ::CMsgServerPeer& CSVCMsg_PeerList::peer(int index) const {
  // @@protoc_insertion_point(field_get:CSVCMsg_PeerList.peer)
  return _internal_peer(index);
}
inline ::CMsgServerPeer* CSVCMsg_PeerList::_internal_add_peer() {
  return _impl_.peer_.Add();
}
inline ::CMsgServerPeer* CSVCMsg_PeerList::add_peer() {
  ::CMsgServerPeer* _add = _internal_add_peer();
  // @@protoc_insertion_point(field_add:CSVCMsg_PeerList.peer)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerPeer >&
CSVCMsg_PeerList::peer() const {
  // @@protoc_insertion_point(field_list:CSVCMsg_PeerList.peer)
  return _impl_.peer_;
}

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

// CSVCMsg_ClearAllStringTables

// optional string mapname = 1;
inline bool CSVCMsg_ClearAllStringTables::_internal_has_mapname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_ClearAllStringTables::has_mapname() const {
  return _internal_has_mapname();
}
inline void CSVCMsg_ClearAllStringTables::clear_mapname() {
  _impl_.mapname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_ClearAllStringTables::mapname() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ClearAllStringTables.mapname)
  return _internal_mapname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_ClearAllStringTables::set_mapname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.mapname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_ClearAllStringTables.mapname)
}
inline std::string* CSVCMsg_ClearAllStringTables::mutable_mapname() {
  std::string* _s = _internal_mutable_mapname();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_ClearAllStringTables.mapname)
  return _s;
}
inline const std::string& CSVCMsg_ClearAllStringTables::_internal_mapname() const {
  return _impl_.mapname_.Get();
}
inline void CSVCMsg_ClearAllStringTables::_internal_set_mapname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.mapname_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_ClearAllStringTables::_internal_mutable_mapname() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.mapname_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_ClearAllStringTables::release_mapname() {
  // @@protoc_insertion_point(field_release:CSVCMsg_ClearAllStringTables.mapname)
  if (!_internal_has_mapname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.mapname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mapname_.IsDefault()) {
    _impl_.mapname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_ClearAllStringTables::set_allocated_mapname(std::string* mapname) {
  if (mapname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.mapname_.SetAllocated(mapname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mapname_.IsDefault()) {
    _impl_.mapname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_ClearAllStringTables.mapname)
}

// optional bool create_tables_skipped = 3;
inline bool CSVCMsg_ClearAllStringTables::_internal_has_create_tables_skipped() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_ClearAllStringTables::has_create_tables_skipped() const {
  return _internal_has_create_tables_skipped();
}
inline void CSVCMsg_ClearAllStringTables::clear_create_tables_skipped() {
  _impl_.create_tables_skipped_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CSVCMsg_ClearAllStringTables::_internal_create_tables_skipped() const {
  return _impl_.create_tables_skipped_;
}
inline bool CSVCMsg_ClearAllStringTables::create_tables_skipped() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_ClearAllStringTables.create_tables_skipped)
  return _internal_create_tables_skipped();
}
inline void CSVCMsg_ClearAllStringTables::_internal_set_create_tables_skipped(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.create_tables_skipped_ = value;
}
inline void CSVCMsg_ClearAllStringTables::set_create_tables_skipped(bool value) {
  _internal_set_create_tables_skipped(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_ClearAllStringTables.create_tables_skipped)
}

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

// ProtoFlattenedSerializerField_t_polymorphic_field_t

// optional int32 polymorphic_field_serializer_name_sym = 1;
inline bool ProtoFlattenedSerializerField_t_polymorphic_field_t::_internal_has_polymorphic_field_serializer_name_sym() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ProtoFlattenedSerializerField_t_polymorphic_field_t::has_polymorphic_field_serializer_name_sym() const {
  return _internal_has_polymorphic_field_serializer_name_sym();
}
inline void ProtoFlattenedSerializerField_t_polymorphic_field_t::clear_polymorphic_field_serializer_name_sym() {
  _impl_.polymorphic_field_serializer_name_sym_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t ProtoFlattenedSerializerField_t_polymorphic_field_t::_internal_polymorphic_field_serializer_name_sym() const {
  return _impl_.polymorphic_field_serializer_name_sym_;
}
inline int32_t ProtoFlattenedSerializerField_t_polymorphic_field_t::polymorphic_field_serializer_name_sym() const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializerField_t.polymorphic_field_t.polymorphic_field_serializer_name_sym)
  return _internal_polymorphic_field_serializer_name_sym();
}
inline void ProtoFlattenedSerializerField_t_polymorphic_field_t::_internal_set_polymorphic_field_serializer_name_sym(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.polymorphic_field_serializer_name_sym_ = value;
}
inline void ProtoFlattenedSerializerField_t_polymorphic_field_t::set_polymorphic_field_serializer_name_sym(int32_t value) {
  _internal_set_polymorphic_field_serializer_name_sym(value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializerField_t.polymorphic_field_t.polymorphic_field_serializer_name_sym)
}

// optional int32 polymorphic_field_serializer_version = 2;
inline bool ProtoFlattenedSerializerField_t_polymorphic_field_t::_internal_has_polymorphic_field_serializer_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ProtoFlattenedSerializerField_t_polymorphic_field_t::has_polymorphic_field_serializer_version() const {
  return _internal_has_polymorphic_field_serializer_version();
}
inline void ProtoFlattenedSerializerField_t_polymorphic_field_t::clear_polymorphic_field_serializer_version() {
  _impl_.polymorphic_field_serializer_version_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t ProtoFlattenedSerializerField_t_polymorphic_field_t::_internal_polymorphic_field_serializer_version() const {
  return _impl_.polymorphic_field_serializer_version_;
}
inline int32_t ProtoFlattenedSerializerField_t_polymorphic_field_t::polymorphic_field_serializer_version() const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializerField_t.polymorphic_field_t.polymorphic_field_serializer_version)
  return _internal_polymorphic_field_serializer_version();
}
inline void ProtoFlattenedSerializerField_t_polymorphic_field_t::_internal_set_polymorphic_field_serializer_version(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.polymorphic_field_serializer_version_ = value;
}
inline void ProtoFlattenedSerializerField_t_polymorphic_field_t::set_polymorphic_field_serializer_version(int32_t value) {
  _internal_set_polymorphic_field_serializer_version(value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializerField_t.polymorphic_field_t.polymorphic_field_serializer_version)
}

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

// ProtoFlattenedSerializerField_t

// optional int32 var_type_sym = 1;
inline bool ProtoFlattenedSerializerField_t::_internal_has_var_type_sym() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ProtoFlattenedSerializerField_t::has_var_type_sym() const {
  return _internal_has_var_type_sym();
}
inline void ProtoFlattenedSerializerField_t::clear_var_type_sym() {
  _impl_.var_type_sym_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t ProtoFlattenedSerializerField_t::_internal_var_type_sym() const {
  return _impl_.var_type_sym_;
}
inline int32_t ProtoFlattenedSerializerField_t::var_type_sym() const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializerField_t.var_type_sym)
  return _internal_var_type_sym();
}
inline void ProtoFlattenedSerializerField_t::_internal_set_var_type_sym(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.var_type_sym_ = value;
}
inline void ProtoFlattenedSerializerField_t::set_var_type_sym(int32_t value) {
  _internal_set_var_type_sym(value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializerField_t.var_type_sym)
}

// optional int32 var_name_sym = 2;
inline bool ProtoFlattenedSerializerField_t::_internal_has_var_name_sym() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ProtoFlattenedSerializerField_t::has_var_name_sym() const {
  return _internal_has_var_name_sym();
}
inline void ProtoFlattenedSerializerField_t::clear_var_name_sym() {
  _impl_.var_name_sym_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t ProtoFlattenedSerializerField_t::_internal_var_name_sym() const {
  return _impl_.var_name_sym_;
}
inline int32_t ProtoFlattenedSerializerField_t::var_name_sym() const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializerField_t.var_name_sym)
  return _internal_var_name_sym();
}
inline void ProtoFlattenedSerializerField_t::_internal_set_var_name_sym(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.var_name_sym_ = value;
}
inline void ProtoFlattenedSerializerField_t::set_var_name_sym(int32_t value) {
  _internal_set_var_name_sym(value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializerField_t.var_name_sym)
}

// optional int32 bit_count = 3;
inline bool ProtoFlattenedSerializerField_t::_internal_has_bit_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ProtoFlattenedSerializerField_t::has_bit_count() const {
  return _internal_has_bit_count();
}
inline void ProtoFlattenedSerializerField_t::clear_bit_count() {
  _impl_.bit_count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t ProtoFlattenedSerializerField_t::_internal_bit_count() const {
  return _impl_.bit_count_;
}
inline int32_t ProtoFlattenedSerializerField_t::bit_count() const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializerField_t.bit_count)
  return _internal_bit_count();
}
inline void ProtoFlattenedSerializerField_t::_internal_set_bit_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.bit_count_ = value;
}
inline void ProtoFlattenedSerializerField_t::set_bit_count(int32_t value) {
  _internal_set_bit_count(value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializerField_t.bit_count)
}

// optional float low_value = 4;
inline bool ProtoFlattenedSerializerField_t::_internal_has_low_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ProtoFlattenedSerializerField_t::has_low_value() const {
  return _internal_has_low_value();
}
inline void ProtoFlattenedSerializerField_t::clear_low_value() {
  _impl_.low_value_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float ProtoFlattenedSerializerField_t::_internal_low_value() const {
  return _impl_.low_value_;
}
inline float ProtoFlattenedSerializerField_t::low_value() const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializerField_t.low_value)
  return _internal_low_value();
}
inline void ProtoFlattenedSerializerField_t::_internal_set_low_value(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.low_value_ = value;
}
inline void ProtoFlattenedSerializerField_t::set_low_value(float value) {
  _internal_set_low_value(value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializerField_t.low_value)
}

// optional float high_value = 5;
inline bool ProtoFlattenedSerializerField_t::_internal_has_high_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ProtoFlattenedSerializerField_t::has_high_value() const {
  return _internal_has_high_value();
}
inline void ProtoFlattenedSerializerField_t::clear_high_value() {
  _impl_.high_value_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float ProtoFlattenedSerializerField_t::_internal_high_value() const {
  return _impl_.high_value_;
}
inline float ProtoFlattenedSerializerField_t::high_value() const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializerField_t.high_value)
  return _internal_high_value();
}
inline void ProtoFlattenedSerializerField_t::_internal_set_high_value(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.high_value_ = value;
}
inline void ProtoFlattenedSerializerField_t::set_high_value(float value) {
  _internal_set_high_value(value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializerField_t.high_value)
}

// optional int32 encode_flags = 6;
inline bool ProtoFlattenedSerializerField_t::_internal_has_encode_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool ProtoFlattenedSerializerField_t::has_encode_flags() const {
  return _internal_has_encode_flags();
}
inline void ProtoFlattenedSerializerField_t::clear_encode_flags() {
  _impl_.encode_flags_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t ProtoFlattenedSerializerField_t::_internal_encode_flags() const {
  return _impl_.encode_flags_;
}
inline int32_t ProtoFlattenedSerializerField_t::encode_flags() const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializerField_t.encode_flags)
  return _internal_encode_flags();
}
inline void ProtoFlattenedSerializerField_t::_internal_set_encode_flags(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.encode_flags_ = value;
}
inline void ProtoFlattenedSerializerField_t::set_encode_flags(int32_t value) {
  _internal_set_encode_flags(value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializerField_t.encode_flags)
}

// optional int32 field_serializer_name_sym = 7;
inline bool ProtoFlattenedSerializerField_t::_internal_has_field_serializer_name_sym() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool ProtoFlattenedSerializerField_t::has_field_serializer_name_sym() const {
  return _internal_has_field_serializer_name_sym();
}
inline void ProtoFlattenedSerializerField_t::clear_field_serializer_name_sym() {
  _impl_.field_serializer_name_sym_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t ProtoFlattenedSerializerField_t::_internal_field_serializer_name_sym() const {
  return _impl_.field_serializer_name_sym_;
}
inline int32_t ProtoFlattenedSerializerField_t::field_serializer_name_sym() const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializerField_t.field_serializer_name_sym)
  return _internal_field_serializer_name_sym();
}
inline void ProtoFlattenedSerializerField_t::_internal_set_field_serializer_name_sym(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.field_serializer_name_sym_ = value;
}
inline void ProtoFlattenedSerializerField_t::set_field_serializer_name_sym(int32_t value) {
  _internal_set_field_serializer_name_sym(value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializerField_t.field_serializer_name_sym)
}

// optional int32 field_serializer_version = 8;
inline bool ProtoFlattenedSerializerField_t::_internal_has_field_serializer_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool ProtoFlattenedSerializerField_t::has_field_serializer_version() const {
  return _internal_has_field_serializer_version();
}
inline void ProtoFlattenedSerializerField_t::clear_field_serializer_version() {
  _impl_.field_serializer_version_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t ProtoFlattenedSerializerField_t::_internal_field_serializer_version() const {
  return _impl_.field_serializer_version_;
}
inline int32_t ProtoFlattenedSerializerField_t::field_serializer_version() const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializerField_t.field_serializer_version)
  return _internal_field_serializer_version();
}
inline void ProtoFlattenedSerializerField_t::_internal_set_field_serializer_version(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.field_serializer_version_ = value;
}
inline void ProtoFlattenedSerializerField_t::set_field_serializer_version(int32_t value) {
  _internal_set_field_serializer_version(value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializerField_t.field_serializer_version)
}

// optional int32 send_node_sym = 9;
inline bool ProtoFlattenedSerializerField_t::_internal_has_send_node_sym() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool ProtoFlattenedSerializerField_t::has_send_node_sym() const {
  return _internal_has_send_node_sym();
}
inline void ProtoFlattenedSerializerField_t::clear_send_node_sym() {
  _impl_.send_node_sym_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int32_t ProtoFlattenedSerializerField_t::_internal_send_node_sym() const {
  return _impl_.send_node_sym_;
}
inline int32_t ProtoFlattenedSerializerField_t::send_node_sym() const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializerField_t.send_node_sym)
  return _internal_send_node_sym();
}
inline void ProtoFlattenedSerializerField_t::_internal_set_send_node_sym(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.send_node_sym_ = value;
}
inline void ProtoFlattenedSerializerField_t::set_send_node_sym(int32_t value) {
  _internal_set_send_node_sym(value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializerField_t.send_node_sym)
}

// optional int32 var_encoder_sym = 10;
inline bool ProtoFlattenedSerializerField_t::_internal_has_var_encoder_sym() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool ProtoFlattenedSerializerField_t::has_var_encoder_sym() const {
  return _internal_has_var_encoder_sym();
}
inline void ProtoFlattenedSerializerField_t::clear_var_encoder_sym() {
  _impl_.var_encoder_sym_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t ProtoFlattenedSerializerField_t::_internal_var_encoder_sym() const {
  return _impl_.var_encoder_sym_;
}
inline int32_t ProtoFlattenedSerializerField_t::var_encoder_sym() const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializerField_t.var_encoder_sym)
  return _internal_var_encoder_sym();
}
inline void ProtoFlattenedSerializerField_t::_internal_set_var_encoder_sym(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.var_encoder_sym_ = value;
}
inline void ProtoFlattenedSerializerField_t::set_var_encoder_sym(int32_t value) {
  _internal_set_var_encoder_sym(value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializerField_t.var_encoder_sym)
}

// repeated .ProtoFlattenedSerializerField_t.polymorphic_field_t polymorphic_types = 11;
inline int ProtoFlattenedSerializerField_t::_internal_polymorphic_types_size() const {
  return _impl_.polymorphic_types_.size();
}
inline int ProtoFlattenedSerializerField_t::polymorphic_types_size() const {
  return _internal_polymorphic_types_size();
}
inline void ProtoFlattenedSerializerField_t::clear_polymorphic_types() {
  _impl_.polymorphic_types_.Clear();
}
inline ::ProtoFlattenedSerializerField_t_polymorphic_field_t* ProtoFlattenedSerializerField_t::mutable_polymorphic_types(int index) {
  // @@protoc_insertion_point(field_mutable:ProtoFlattenedSerializerField_t.polymorphic_types)
  return _impl_.polymorphic_types_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ProtoFlattenedSerializerField_t_polymorphic_field_t >*
ProtoFlattenedSerializerField_t::mutable_polymorphic_types() {
  // @@protoc_insertion_point(field_mutable_list:ProtoFlattenedSerializerField_t.polymorphic_types)
  return &_impl_.polymorphic_types_;
}
inline const ::ProtoFlattenedSerializerField_t_polymorphic_field_t& ProtoFlattenedSerializerField_t::_internal_polymorphic_types(int index) const {
  return _impl_.polymorphic_types_.Get(index);
}
inline const ::ProtoFlattenedSerializerField_t_polymorphic_field_t& ProtoFlattenedSerializerField_t::polymorphic_types(int index) const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializerField_t.polymorphic_types)
  return _internal_polymorphic_types(index);
}
inline ::ProtoFlattenedSerializerField_t_polymorphic_field_t* ProtoFlattenedSerializerField_t::_internal_add_polymorphic_types() {
  return _impl_.polymorphic_types_.Add();
}
inline ::ProtoFlattenedSerializerField_t_polymorphic_field_t* ProtoFlattenedSerializerField_t::add_polymorphic_types() {
  ::ProtoFlattenedSerializerField_t_polymorphic_field_t* _add = _internal_add_polymorphic_types();
  // @@protoc_insertion_point(field_add:ProtoFlattenedSerializerField_t.polymorphic_types)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ProtoFlattenedSerializerField_t_polymorphic_field_t >&
ProtoFlattenedSerializerField_t::polymorphic_types() const {
  // @@protoc_insertion_point(field_list:ProtoFlattenedSerializerField_t.polymorphic_types)
  return _impl_.polymorphic_types_;
}

// optional int32 var_serializer_sym = 12;
inline bool ProtoFlattenedSerializerField_t::_internal_has_var_serializer_sym() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool ProtoFlattenedSerializerField_t::has_var_serializer_sym() const {
  return _internal_has_var_serializer_sym();
}
inline void ProtoFlattenedSerializerField_t::clear_var_serializer_sym() {
  _impl_.var_serializer_sym_ = 0;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline int32_t ProtoFlattenedSerializerField_t::_internal_var_serializer_sym() const {
  return _impl_.var_serializer_sym_;
}
inline int32_t ProtoFlattenedSerializerField_t::var_serializer_sym() const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializerField_t.var_serializer_sym)
  return _internal_var_serializer_sym();
}
inline void ProtoFlattenedSerializerField_t::_internal_set_var_serializer_sym(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.var_serializer_sym_ = value;
}
inline void ProtoFlattenedSerializerField_t::set_var_serializer_sym(int32_t value) {
  _internal_set_var_serializer_sym(value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializerField_t.var_serializer_sym)
}

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

// ProtoFlattenedSerializer_t

// optional int32 serializer_name_sym = 1;
inline bool ProtoFlattenedSerializer_t::_internal_has_serializer_name_sym() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ProtoFlattenedSerializer_t::has_serializer_name_sym() const {
  return _internal_has_serializer_name_sym();
}
inline void ProtoFlattenedSerializer_t::clear_serializer_name_sym() {
  _impl_.serializer_name_sym_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t ProtoFlattenedSerializer_t::_internal_serializer_name_sym() const {
  return _impl_.serializer_name_sym_;
}
inline int32_t ProtoFlattenedSerializer_t::serializer_name_sym() const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializer_t.serializer_name_sym)
  return _internal_serializer_name_sym();
}
inline void ProtoFlattenedSerializer_t::_internal_set_serializer_name_sym(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.serializer_name_sym_ = value;
}
inline void ProtoFlattenedSerializer_t::set_serializer_name_sym(int32_t value) {
  _internal_set_serializer_name_sym(value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializer_t.serializer_name_sym)
}

// optional int32 serializer_version = 2;
inline bool ProtoFlattenedSerializer_t::_internal_has_serializer_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ProtoFlattenedSerializer_t::has_serializer_version() const {
  return _internal_has_serializer_version();
}
inline void ProtoFlattenedSerializer_t::clear_serializer_version() {
  _impl_.serializer_version_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t ProtoFlattenedSerializer_t::_internal_serializer_version() const {
  return _impl_.serializer_version_;
}
inline int32_t ProtoFlattenedSerializer_t::serializer_version() const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializer_t.serializer_version)
  return _internal_serializer_version();
}
inline void ProtoFlattenedSerializer_t::_internal_set_serializer_version(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.serializer_version_ = value;
}
inline void ProtoFlattenedSerializer_t::set_serializer_version(int32_t value) {
  _internal_set_serializer_version(value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializer_t.serializer_version)
}

// repeated int32 fields_index = 3;
inline int ProtoFlattenedSerializer_t::_internal_fields_index_size() const {
  return _impl_.fields_index_.size();
}
inline int ProtoFlattenedSerializer_t::fields_index_size() const {
  return _internal_fields_index_size();
}
inline void ProtoFlattenedSerializer_t::clear_fields_index() {
  _impl_.fields_index_.Clear();
}
inline int32_t ProtoFlattenedSerializer_t::_internal_fields_index(int index) const {
  return _impl_.fields_index_.Get(index);
}
inline int32_t ProtoFlattenedSerializer_t::fields_index(int index) const {
  // @@protoc_insertion_point(field_get:ProtoFlattenedSerializer_t.fields_index)
  return _internal_fields_index(index);
}
inline void ProtoFlattenedSerializer_t::set_fields_index(int index, int32_t value) {
  _impl_.fields_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:ProtoFlattenedSerializer_t.fields_index)
}
inline void ProtoFlattenedSerializer_t::_internal_add_fields_index(int32_t value) {
  _impl_.fields_index_.Add(value);
}
inline void ProtoFlattenedSerializer_t::add_fields_index(int32_t value) {
  _internal_add_fields_index(value);
  // @@protoc_insertion_point(field_add:ProtoFlattenedSerializer_t.fields_index)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ProtoFlattenedSerializer_t::_internal_fields_index() const {
  return _impl_.fields_index_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ProtoFlattenedSerializer_t::fields_index() const {
  // @@protoc_insertion_point(field_list:ProtoFlattenedSerializer_t.fields_index)
  return _internal_fields_index();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ProtoFlattenedSerializer_t::_internal_mutable_fields_index() {
  return &_impl_.fields_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ProtoFlattenedSerializer_t::mutable_fields_index() {
  // @@protoc_insertion_point(field_mutable_list:ProtoFlattenedSerializer_t.fields_index)
  return _internal_mutable_fields_index();
}

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

// CSVCMsg_FlattenedSerializer

// repeated .ProtoFlattenedSerializer_t serializers = 1;
inline int CSVCMsg_FlattenedSerializer::_internal_serializers_size() const {
  return _impl_.serializers_.size();
}
inline int CSVCMsg_FlattenedSerializer::serializers_size() const {
  return _internal_serializers_size();
}
inline void CSVCMsg_FlattenedSerializer::clear_serializers() {
  _impl_.serializers_.Clear();
}
inline ::ProtoFlattenedSerializer_t* CSVCMsg_FlattenedSerializer::mutable_serializers(int index) {
  // @@protoc_insertion_point(field_mutable:CSVCMsg_FlattenedSerializer.serializers)
  return _impl_.serializers_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ProtoFlattenedSerializer_t >*
CSVCMsg_FlattenedSerializer::mutable_serializers() {
  // @@protoc_insertion_point(field_mutable_list:CSVCMsg_FlattenedSerializer.serializers)
  return &_impl_.serializers_;
}
inline const ::ProtoFlattenedSerializer_t& CSVCMsg_FlattenedSerializer::_internal_serializers(int index) const {
  return _impl_.serializers_.Get(index);
}
inline const ::ProtoFlattenedSerializer_t& CSVCMsg_FlattenedSerializer::serializers(int index) const {
  // @@protoc_insertion_point(field_get:CSVCMsg_FlattenedSerializer.serializers)
  return _internal_serializers(index);
}
inline ::ProtoFlattenedSerializer_t* CSVCMsg_FlattenedSerializer::_internal_add_serializers() {
  return _impl_.serializers_.Add();
}
inline ::ProtoFlattenedSerializer_t* CSVCMsg_FlattenedSerializer::add_serializers() {
  ::ProtoFlattenedSerializer_t* _add = _internal_add_serializers();
  // @@protoc_insertion_point(field_add:CSVCMsg_FlattenedSerializer.serializers)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ProtoFlattenedSerializer_t >&
CSVCMsg_FlattenedSerializer::serializers() const {
  // @@protoc_insertion_point(field_list:CSVCMsg_FlattenedSerializer.serializers)
  return _impl_.serializers_;
}

// repeated string symbols = 2;
inline int CSVCMsg_FlattenedSerializer::_internal_symbols_size() const {
  return _impl_.symbols_.size();
}
inline int CSVCMsg_FlattenedSerializer::symbols_size() const {
  return _internal_symbols_size();
}
inline void CSVCMsg_FlattenedSerializer::clear_symbols() {
  _impl_.symbols_.Clear();
}
inline std::string* CSVCMsg_FlattenedSerializer::add_symbols() {
  std::string* _s = _internal_add_symbols();
  // @@protoc_insertion_point(field_add_mutable:CSVCMsg_FlattenedSerializer.symbols)
  return _s;
}
inline const std::string& CSVCMsg_FlattenedSerializer::_internal_symbols(int index) const {
  return _impl_.symbols_.Get(index);
}
inline const std::string& CSVCMsg_FlattenedSerializer::symbols(int index) const {
  // @@protoc_insertion_point(field_get:CSVCMsg_FlattenedSerializer.symbols)
  return _internal_symbols(index);
}
inline std::string* CSVCMsg_FlattenedSerializer::mutable_symbols(int index) {
  // @@protoc_insertion_point(field_mutable:CSVCMsg_FlattenedSerializer.symbols)
  return _impl_.symbols_.Mutable(index);
}
inline void CSVCMsg_FlattenedSerializer::set_symbols(int index, const std::string& value) {
  _impl_.symbols_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_FlattenedSerializer.symbols)
}
inline void CSVCMsg_FlattenedSerializer::set_symbols(int index, std::string&& value) {
  _impl_.symbols_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:CSVCMsg_FlattenedSerializer.symbols)
}
inline void CSVCMsg_FlattenedSerializer::set_symbols(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.symbols_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:CSVCMsg_FlattenedSerializer.symbols)
}
inline void CSVCMsg_FlattenedSerializer::set_symbols(int index, const char* value, size_t size) {
  _impl_.symbols_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:CSVCMsg_FlattenedSerializer.symbols)
}
inline std::string* CSVCMsg_FlattenedSerializer::_internal_add_symbols() {
  return _impl_.symbols_.Add();
}
inline void CSVCMsg_FlattenedSerializer::add_symbols(const std::string& value) {
  _impl_.symbols_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:CSVCMsg_FlattenedSerializer.symbols)
}
inline void CSVCMsg_FlattenedSerializer::add_symbols(std::string&& value) {
  _impl_.symbols_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:CSVCMsg_FlattenedSerializer.symbols)
}
inline void CSVCMsg_FlattenedSerializer::add_symbols(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.symbols_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:CSVCMsg_FlattenedSerializer.symbols)
}
inline void CSVCMsg_FlattenedSerializer::add_symbols(const char* value, size_t size) {
  _impl_.symbols_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:CSVCMsg_FlattenedSerializer.symbols)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
CSVCMsg_FlattenedSerializer::symbols() const {
  // @@protoc_insertion_point(field_list:CSVCMsg_FlattenedSerializer.symbols)
  return _impl_.symbols_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
CSVCMsg_FlattenedSerializer::mutable_symbols() {
  // @@protoc_insertion_point(field_mutable_list:CSVCMsg_FlattenedSerializer.symbols)
  return &_impl_.symbols_;
}

// repeated .ProtoFlattenedSerializerField_t fields = 3;
inline int CSVCMsg_FlattenedSerializer::_internal_fields_size() const {
  return _impl_.fields_.size();
}
inline int CSVCMsg_FlattenedSerializer::fields_size() const {
  return _internal_fields_size();
}
inline void CSVCMsg_FlattenedSerializer::clear_fields() {
  _impl_.fields_.Clear();
}
inline ::ProtoFlattenedSerializerField_t* CSVCMsg_FlattenedSerializer::mutable_fields(int index) {
  // @@protoc_insertion_point(field_mutable:CSVCMsg_FlattenedSerializer.fields)
  return _impl_.fields_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ProtoFlattenedSerializerField_t >*
CSVCMsg_FlattenedSerializer::mutable_fields() {
  // @@protoc_insertion_point(field_mutable_list:CSVCMsg_FlattenedSerializer.fields)
  return &_impl_.fields_;
}
inline const ::ProtoFlattenedSerializerField_t& CSVCMsg_FlattenedSerializer::_internal_fields(int index) const {
  return _impl_.fields_.Get(index);
}
inline const ::ProtoFlattenedSerializerField_t& CSVCMsg_FlattenedSerializer::fields(int index) const {
  // @@protoc_insertion_point(field_get:CSVCMsg_FlattenedSerializer.fields)
  return _internal_fields(index);
}
inline ::ProtoFlattenedSerializerField_t* CSVCMsg_FlattenedSerializer::_internal_add_fields() {
  return _impl_.fields_.Add();
}
inline ::ProtoFlattenedSerializerField_t* CSVCMsg_FlattenedSerializer::add_fields() {
  ::ProtoFlattenedSerializerField_t* _add = _internal_add_fields();
  // @@protoc_insertion_point(field_add:CSVCMsg_FlattenedSerializer.fields)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ProtoFlattenedSerializerField_t >&
CSVCMsg_FlattenedSerializer::fields() const {
  // @@protoc_insertion_point(field_list:CSVCMsg_FlattenedSerializer.fields)
  return _impl_.fields_;
}

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

// CSVCMsg_StopSound

// optional fixed32 guid = 1;
inline bool CSVCMsg_StopSound::_internal_has_guid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_StopSound::has_guid() const {
  return _internal_has_guid();
}
inline void CSVCMsg_StopSound::clear_guid() {
  _impl_.guid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CSVCMsg_StopSound::_internal_guid() const {
  return _impl_.guid_;
}
inline uint32_t CSVCMsg_StopSound::guid() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_StopSound.guid)
  return _internal_guid();
}
inline void CSVCMsg_StopSound::_internal_set_guid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.guid_ = value;
}
inline void CSVCMsg_StopSound::set_guid(uint32_t value) {
  _internal_set_guid(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_StopSound.guid)
}

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

// CBidirMsg_RebroadcastGameEvent

// optional bool posttoserver = 1;
inline bool CBidirMsg_RebroadcastGameEvent::_internal_has_posttoserver() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CBidirMsg_RebroadcastGameEvent::has_posttoserver() const {
  return _internal_has_posttoserver();
}
inline void CBidirMsg_RebroadcastGameEvent::clear_posttoserver() {
  _impl_.posttoserver_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CBidirMsg_RebroadcastGameEvent::_internal_posttoserver() const {
  return _impl_.posttoserver_;
}
inline bool CBidirMsg_RebroadcastGameEvent::posttoserver() const {
  // @@protoc_insertion_point(field_get:CBidirMsg_RebroadcastGameEvent.posttoserver)
  return _internal_posttoserver();
}
inline void CBidirMsg_RebroadcastGameEvent::_internal_set_posttoserver(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.posttoserver_ = value;
}
inline void CBidirMsg_RebroadcastGameEvent::set_posttoserver(bool value) {
  _internal_set_posttoserver(value);
  // @@protoc_insertion_point(field_set:CBidirMsg_RebroadcastGameEvent.posttoserver)
}

// optional int32 buftype = 2;
inline bool CBidirMsg_RebroadcastGameEvent::_internal_has_buftype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CBidirMsg_RebroadcastGameEvent::has_buftype() const {
  return _internal_has_buftype();
}
inline void CBidirMsg_RebroadcastGameEvent::clear_buftype() {
  _impl_.buftype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CBidirMsg_RebroadcastGameEvent::_internal_buftype() const {
  return _impl_.buftype_;
}
inline int32_t CBidirMsg_RebroadcastGameEvent::buftype() const {
  // @@protoc_insertion_point(field_get:CBidirMsg_RebroadcastGameEvent.buftype)
  return _internal_buftype();
}
inline void CBidirMsg_RebroadcastGameEvent::_internal_set_buftype(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.buftype_ = value;
}
inline void CBidirMsg_RebroadcastGameEvent::set_buftype(int32_t value) {
  _internal_set_buftype(value);
  // @@protoc_insertion_point(field_set:CBidirMsg_RebroadcastGameEvent.buftype)
}

// optional uint32 clientbitcount = 3;
inline bool CBidirMsg_RebroadcastGameEvent::_internal_has_clientbitcount() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CBidirMsg_RebroadcastGameEvent::has_clientbitcount() const {
  return _internal_has_clientbitcount();
}
inline void CBidirMsg_RebroadcastGameEvent::clear_clientbitcount() {
  _impl_.clientbitcount_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CBidirMsg_RebroadcastGameEvent::_internal_clientbitcount() const {
  return _impl_.clientbitcount_;
}
inline uint32_t CBidirMsg_RebroadcastGameEvent::clientbitcount() const {
  // @@protoc_insertion_point(field_get:CBidirMsg_RebroadcastGameEvent.clientbitcount)
  return _internal_clientbitcount();
}
inline void CBidirMsg_RebroadcastGameEvent::_internal_set_clientbitcount(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.clientbitcount_ = value;
}
inline void CBidirMsg_RebroadcastGameEvent::set_clientbitcount(uint32_t value) {
  _internal_set_clientbitcount(value);
  // @@protoc_insertion_point(field_set:CBidirMsg_RebroadcastGameEvent.clientbitcount)
}

// optional uint64 receivingclients = 4;
inline bool CBidirMsg_RebroadcastGameEvent::_internal_has_receivingclients() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CBidirMsg_RebroadcastGameEvent::has_receivingclients() const {
  return _internal_has_receivingclients();
}
inline void CBidirMsg_RebroadcastGameEvent::clear_receivingclients() {
  _impl_.receivingclients_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CBidirMsg_RebroadcastGameEvent::_internal_receivingclients() const {
  return _impl_.receivingclients_;
}
inline uint64_t CBidirMsg_RebroadcastGameEvent::receivingclients() const {
  // @@protoc_insertion_point(field_get:CBidirMsg_RebroadcastGameEvent.receivingclients)
  return _internal_receivingclients();
}
inline void CBidirMsg_RebroadcastGameEvent::_internal_set_receivingclients(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.receivingclients_ = value;
}
inline void CBidirMsg_RebroadcastGameEvent::set_receivingclients(uint64_t value) {
  _internal_set_receivingclients(value);
  // @@protoc_insertion_point(field_set:CBidirMsg_RebroadcastGameEvent.receivingclients)
}

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

// CBidirMsg_RebroadcastSource

// optional int32 eventsource = 1;
inline bool CBidirMsg_RebroadcastSource::_internal_has_eventsource() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CBidirMsg_RebroadcastSource::has_eventsource() const {
  return _internal_has_eventsource();
}
inline void CBidirMsg_RebroadcastSource::clear_eventsource() {
  _impl_.eventsource_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CBidirMsg_RebroadcastSource::_internal_eventsource() const {
  return _impl_.eventsource_;
}
inline int32_t CBidirMsg_RebroadcastSource::eventsource() const {
  // @@protoc_insertion_point(field_get:CBidirMsg_RebroadcastSource.eventsource)
  return _internal_eventsource();
}
inline void CBidirMsg_RebroadcastSource::_internal_set_eventsource(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.eventsource_ = value;
}
inline void CBidirMsg_RebroadcastSource::set_eventsource(int32_t value) {
  _internal_set_eventsource(value);
  // @@protoc_insertion_point(field_set:CBidirMsg_RebroadcastSource.eventsource)
}

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

// CBidirMsg_PredictionEvent

// optional uint32 event_id = 1;
inline bool CBidirMsg_PredictionEvent::_internal_has_event_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CBidirMsg_PredictionEvent::has_event_id() const {
  return _internal_has_event_id();
}
inline void CBidirMsg_PredictionEvent::clear_event_id() {
  _impl_.event_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CBidirMsg_PredictionEvent::_internal_event_id() const {
  return _impl_.event_id_;
}
inline uint32_t CBidirMsg_PredictionEvent::event_id() const {
  // @@protoc_insertion_point(field_get:CBidirMsg_PredictionEvent.event_id)
  return _internal_event_id();
}
inline void CBidirMsg_PredictionEvent::_internal_set_event_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.event_id_ = value;
}
inline void CBidirMsg_PredictionEvent::set_event_id(uint32_t value) {
  _internal_set_event_id(value);
  // @@protoc_insertion_point(field_set:CBidirMsg_PredictionEvent.event_id)
}

// optional bytes event_data = 2;
inline bool CBidirMsg_PredictionEvent::_internal_has_event_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CBidirMsg_PredictionEvent::has_event_data() const {
  return _internal_has_event_data();
}
inline void CBidirMsg_PredictionEvent::clear_event_data() {
  _impl_.event_data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CBidirMsg_PredictionEvent::event_data() const {
  // @@protoc_insertion_point(field_get:CBidirMsg_PredictionEvent.event_data)
  return _internal_event_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CBidirMsg_PredictionEvent::set_event_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.event_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CBidirMsg_PredictionEvent.event_data)
}
inline std::string* CBidirMsg_PredictionEvent::mutable_event_data() {
  std::string* _s = _internal_mutable_event_data();
  // @@protoc_insertion_point(field_mutable:CBidirMsg_PredictionEvent.event_data)
  return _s;
}
inline const std::string& CBidirMsg_PredictionEvent::_internal_event_data() const {
  return _impl_.event_data_.Get();
}
inline void CBidirMsg_PredictionEvent::_internal_set_event_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.event_data_.Set(value, GetArenaForAllocation());
}
inline std::string* CBidirMsg_PredictionEvent::_internal_mutable_event_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.event_data_.Mutable(GetArenaForAllocation());
}
inline std::string* CBidirMsg_PredictionEvent::release_event_data() {
  // @@protoc_insertion_point(field_release:CBidirMsg_PredictionEvent.event_data)
  if (!_internal_has_event_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.event_data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.event_data_.IsDefault()) {
    _impl_.event_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CBidirMsg_PredictionEvent::set_allocated_event_data(std::string* event_data) {
  if (event_data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.event_data_.SetAllocated(event_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.event_data_.IsDefault()) {
    _impl_.event_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CBidirMsg_PredictionEvent.event_data)
}

// optional uint32 sync_type = 3;
inline bool CBidirMsg_PredictionEvent::_internal_has_sync_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CBidirMsg_PredictionEvent::has_sync_type() const {
  return _internal_has_sync_type();
}
inline void CBidirMsg_PredictionEvent::clear_sync_type() {
  _impl_.sync_type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CBidirMsg_PredictionEvent::_internal_sync_type() const {
  return _impl_.sync_type_;
}
inline uint32_t CBidirMsg_PredictionEvent::sync_type() const {
  // @@protoc_insertion_point(field_get:CBidirMsg_PredictionEvent.sync_type)
  return _internal_sync_type();
}
inline void CBidirMsg_PredictionEvent::_internal_set_sync_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.sync_type_ = value;
}
inline void CBidirMsg_PredictionEvent::set_sync_type(uint32_t value) {
  _internal_set_sync_type(value);
  // @@protoc_insertion_point(field_set:CBidirMsg_PredictionEvent.sync_type)
}

// optional uint32 sync_val_uint32 = 4;
inline bool CBidirMsg_PredictionEvent::_internal_has_sync_val_uint32() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CBidirMsg_PredictionEvent::has_sync_val_uint32() const {
  return _internal_has_sync_val_uint32();
}
inline void CBidirMsg_PredictionEvent::clear_sync_val_uint32() {
  _impl_.sync_val_uint32_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CBidirMsg_PredictionEvent::_internal_sync_val_uint32() const {
  return _impl_.sync_val_uint32_;
}
inline uint32_t CBidirMsg_PredictionEvent::sync_val_uint32() const {
  // @@protoc_insertion_point(field_get:CBidirMsg_PredictionEvent.sync_val_uint32)
  return _internal_sync_val_uint32();
}
inline void CBidirMsg_PredictionEvent::_internal_set_sync_val_uint32(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.sync_val_uint32_ = value;
}
inline void CBidirMsg_PredictionEvent::set_sync_val_uint32(uint32_t value) {
  _internal_set_sync_val_uint32(value);
  // @@protoc_insertion_point(field_set:CBidirMsg_PredictionEvent.sync_val_uint32)
}

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

// CMsgServerNetworkStats_Port

// optional int32 port = 1;
inline bool CMsgServerNetworkStats_Port::_internal_has_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats_Port::has_port() const {
  return _internal_has_port();
}
inline void CMsgServerNetworkStats_Port::clear_port() {
  _impl_.port_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CMsgServerNetworkStats_Port::_internal_port() const {
  return _impl_.port_;
}
inline int32_t CMsgServerNetworkStats_Port::port() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.Port.port)
  return _internal_port();
}
inline void CMsgServerNetworkStats_Port::_internal_set_port(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.port_ = value;
}
inline void CMsgServerNetworkStats_Port::set_port(int32_t value) {
  _internal_set_port(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.Port.port)
}

// optional string name = 2;
inline bool CMsgServerNetworkStats_Port::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats_Port::has_name() const {
  return _internal_has_name();
}
inline void CMsgServerNetworkStats_Port::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgServerNetworkStats_Port::name() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.Port.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgServerNetworkStats_Port::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.Port.name)
}
inline std::string* CMsgServerNetworkStats_Port::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:CMsgServerNetworkStats.Port.name)
  return _s;
}
inline const std::string& CMsgServerNetworkStats_Port::_internal_name() const {
  return _impl_.name_.Get();
}
inline void CMsgServerNetworkStats_Port::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgServerNetworkStats_Port::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgServerNetworkStats_Port::release_name() {
  // @@protoc_insertion_point(field_release:CMsgServerNetworkStats.Port.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgServerNetworkStats_Port::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgServerNetworkStats.Port.name)
}

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

// CMsgServerNetworkStats_Player

// optional uint64 steamid = 1;
inline bool CMsgServerNetworkStats_Player::_internal_has_steamid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats_Player::has_steamid() const {
  return _internal_has_steamid();
}
inline void CMsgServerNetworkStats_Player::clear_steamid() {
  _impl_.steamid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgServerNetworkStats_Player::_internal_steamid() const {
  return _impl_.steamid_;
}
inline uint64_t CMsgServerNetworkStats_Player::steamid() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.Player.steamid)
  return _internal_steamid();
}
inline void CMsgServerNetworkStats_Player::_internal_set_steamid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.steamid_ = value;
}
inline void CMsgServerNetworkStats_Player::set_steamid(uint64_t value) {
  _internal_set_steamid(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.Player.steamid)
}

// optional string remote_addr = 2;
inline bool CMsgServerNetworkStats_Player::_internal_has_remote_addr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats_Player::has_remote_addr() const {
  return _internal_has_remote_addr();
}
inline void CMsgServerNetworkStats_Player::clear_remote_addr() {
  _impl_.remote_addr_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgServerNetworkStats_Player::remote_addr() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.Player.remote_addr)
  return _internal_remote_addr();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgServerNetworkStats_Player::set_remote_addr(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.remote_addr_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.Player.remote_addr)
}
inline std::string* CMsgServerNetworkStats_Player::mutable_remote_addr() {
  std::string* _s = _internal_mutable_remote_addr();
  // @@protoc_insertion_point(field_mutable:CMsgServerNetworkStats.Player.remote_addr)
  return _s;
}
inline const std::string& CMsgServerNetworkStats_Player::_internal_remote_addr() const {
  return _impl_.remote_addr_.Get();
}
inline void CMsgServerNetworkStats_Player::_internal_set_remote_addr(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.remote_addr_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgServerNetworkStats_Player::_internal_mutable_remote_addr() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.remote_addr_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgServerNetworkStats_Player::release_remote_addr() {
  // @@protoc_insertion_point(field_release:CMsgServerNetworkStats.Player.remote_addr)
  if (!_internal_has_remote_addr()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.remote_addr_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.remote_addr_.IsDefault()) {
    _impl_.remote_addr_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgServerNetworkStats_Player::set_allocated_remote_addr(std::string* remote_addr) {
  if (remote_addr != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.remote_addr_.SetAllocated(remote_addr, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.remote_addr_.IsDefault()) {
    _impl_.remote_addr_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgServerNetworkStats.Player.remote_addr)
}

// optional int32 ping_avg_ms = 4;
inline bool CMsgServerNetworkStats_Player::_internal_has_ping_avg_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats_Player::has_ping_avg_ms() const {
  return _internal_has_ping_avg_ms();
}
inline void CMsgServerNetworkStats_Player::clear_ping_avg_ms() {
  _impl_.ping_avg_ms_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CMsgServerNetworkStats_Player::_internal_ping_avg_ms() const {
  return _impl_.ping_avg_ms_;
}
inline int32_t CMsgServerNetworkStats_Player::ping_avg_ms() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.Player.ping_avg_ms)
  return _internal_ping_avg_ms();
}
inline void CMsgServerNetworkStats_Player::_internal_set_ping_avg_ms(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.ping_avg_ms_ = value;
}
inline void CMsgServerNetworkStats_Player::set_ping_avg_ms(int32_t value) {
  _internal_set_ping_avg_ms(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.Player.ping_avg_ms)
}

// optional float packet_loss_pct = 5;
inline bool CMsgServerNetworkStats_Player::_internal_has_packet_loss_pct() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats_Player::has_packet_loss_pct() const {
  return _internal_has_packet_loss_pct();
}
inline void CMsgServerNetworkStats_Player::clear_packet_loss_pct() {
  _impl_.packet_loss_pct_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float CMsgServerNetworkStats_Player::_internal_packet_loss_pct() const {
  return _impl_.packet_loss_pct_;
}
inline float CMsgServerNetworkStats_Player::packet_loss_pct() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.Player.packet_loss_pct)
  return _internal_packet_loss_pct();
}
inline void CMsgServerNetworkStats_Player::_internal_set_packet_loss_pct(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.packet_loss_pct_ = value;
}
inline void CMsgServerNetworkStats_Player::set_packet_loss_pct(float value) {
  _internal_set_packet_loss_pct(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.Player.packet_loss_pct)
}

// optional bool is_bot = 6;
inline bool CMsgServerNetworkStats_Player::_internal_has_is_bot() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats_Player::has_is_bot() const {
  return _internal_has_is_bot();
}
inline void CMsgServerNetworkStats_Player::clear_is_bot() {
  _impl_.is_bot_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool CMsgServerNetworkStats_Player::_internal_is_bot() const {
  return _impl_.is_bot_;
}
inline bool CMsgServerNetworkStats_Player::is_bot() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.Player.is_bot)
  return _internal_is_bot();
}
inline void CMsgServerNetworkStats_Player::_internal_set_is_bot(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.is_bot_ = value;
}
inline void CMsgServerNetworkStats_Player::set_is_bot(bool value) {
  _internal_set_is_bot(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.Player.is_bot)
}

// optional float loss_in = 7;
inline bool CMsgServerNetworkStats_Player::_internal_has_loss_in() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats_Player::has_loss_in() const {
  return _internal_has_loss_in();
}
inline void CMsgServerNetworkStats_Player::clear_loss_in() {
  _impl_.loss_in_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float CMsgServerNetworkStats_Player::_internal_loss_in() const {
  return _impl_.loss_in_;
}
inline float CMsgServerNetworkStats_Player::loss_in() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.Player.loss_in)
  return _internal_loss_in();
}
inline void CMsgServerNetworkStats_Player::_internal_set_loss_in(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.loss_in_ = value;
}
inline void CMsgServerNetworkStats_Player::set_loss_in(float value) {
  _internal_set_loss_in(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.Player.loss_in)
}

// optional float loss_out = 8;
inline bool CMsgServerNetworkStats_Player::_internal_has_loss_out() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats_Player::has_loss_out() const {
  return _internal_has_loss_out();
}
inline void CMsgServerNetworkStats_Player::clear_loss_out() {
  _impl_.loss_out_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float CMsgServerNetworkStats_Player::_internal_loss_out() const {
  return _impl_.loss_out_;
}
inline float CMsgServerNetworkStats_Player::loss_out() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.Player.loss_out)
  return _internal_loss_out();
}
inline void CMsgServerNetworkStats_Player::_internal_set_loss_out(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.loss_out_ = value;
}
inline void CMsgServerNetworkStats_Player::set_loss_out(float value) {
  _internal_set_loss_out(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.Player.loss_out)
}

// optional int32 engine_latency_ms = 9;
inline bool CMsgServerNetworkStats_Player::_internal_has_engine_latency_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats_Player::has_engine_latency_ms() const {
  return _internal_has_engine_latency_ms();
}
inline void CMsgServerNetworkStats_Player::clear_engine_latency_ms() {
  _impl_.engine_latency_ms_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t CMsgServerNetworkStats_Player::_internal_engine_latency_ms() const {
  return _impl_.engine_latency_ms_;
}
inline int32_t CMsgServerNetworkStats_Player::engine_latency_ms() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.Player.engine_latency_ms)
  return _internal_engine_latency_ms();
}
inline void CMsgServerNetworkStats_Player::_internal_set_engine_latency_ms(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.engine_latency_ms_ = value;
}
inline void CMsgServerNetworkStats_Player::set_engine_latency_ms(int32_t value) {
  _internal_set_engine_latency_ms(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.Player.engine_latency_ms)
}

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

// CMsgServerNetworkStats

// optional bool dedicated = 1;
inline bool CMsgServerNetworkStats::_internal_has_dedicated() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_dedicated() const {
  return _internal_has_dedicated();
}
inline void CMsgServerNetworkStats::clear_dedicated() {
  _impl_.dedicated_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool CMsgServerNetworkStats::_internal_dedicated() const {
  return _impl_.dedicated_;
}
inline bool CMsgServerNetworkStats::dedicated() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.dedicated)
  return _internal_dedicated();
}
inline void CMsgServerNetworkStats::_internal_set_dedicated(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.dedicated_ = value;
}
inline void CMsgServerNetworkStats::set_dedicated(bool value) {
  _internal_set_dedicated(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.dedicated)
}

// optional int32 cpu_usage = 2;
inline bool CMsgServerNetworkStats::_internal_has_cpu_usage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_cpu_usage() const {
  return _internal_has_cpu_usage();
}
inline void CMsgServerNetworkStats::clear_cpu_usage() {
  _impl_.cpu_usage_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CMsgServerNetworkStats::_internal_cpu_usage() const {
  return _impl_.cpu_usage_;
}
inline int32_t CMsgServerNetworkStats::cpu_usage() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.cpu_usage)
  return _internal_cpu_usage();
}
inline void CMsgServerNetworkStats::_internal_set_cpu_usage(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.cpu_usage_ = value;
}
inline void CMsgServerNetworkStats::set_cpu_usage(int32_t value) {
  _internal_set_cpu_usage(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.cpu_usage)
}

// optional int32 memory_used_mb = 3;
inline bool CMsgServerNetworkStats::_internal_has_memory_used_mb() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_memory_used_mb() const {
  return _internal_has_memory_used_mb();
}
inline void CMsgServerNetworkStats::clear_memory_used_mb() {
  _impl_.memory_used_mb_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CMsgServerNetworkStats::_internal_memory_used_mb() const {
  return _impl_.memory_used_mb_;
}
inline int32_t CMsgServerNetworkStats::memory_used_mb() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.memory_used_mb)
  return _internal_memory_used_mb();
}
inline void CMsgServerNetworkStats::_internal_set_memory_used_mb(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.memory_used_mb_ = value;
}
inline void CMsgServerNetworkStats::set_memory_used_mb(int32_t value) {
  _internal_set_memory_used_mb(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.memory_used_mb)
}

// optional int32 memory_free_mb = 4;
inline bool CMsgServerNetworkStats::_internal_has_memory_free_mb() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_memory_free_mb() const {
  return _internal_has_memory_free_mb();
}
inline void CMsgServerNetworkStats::clear_memory_free_mb() {
  _impl_.memory_free_mb_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CMsgServerNetworkStats::_internal_memory_free_mb() const {
  return _impl_.memory_free_mb_;
}
inline int32_t CMsgServerNetworkStats::memory_free_mb() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.memory_free_mb)
  return _internal_memory_free_mb();
}
inline void CMsgServerNetworkStats::_internal_set_memory_free_mb(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.memory_free_mb_ = value;
}
inline void CMsgServerNetworkStats::set_memory_free_mb(int32_t value) {
  _internal_set_memory_free_mb(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.memory_free_mb)
}

// optional int32 uptime = 5;
inline bool CMsgServerNetworkStats::_internal_has_uptime() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_uptime() const {
  return _internal_has_uptime();
}
inline void CMsgServerNetworkStats::clear_uptime() {
  _impl_.uptime_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CMsgServerNetworkStats::_internal_uptime() const {
  return _impl_.uptime_;
}
inline int32_t CMsgServerNetworkStats::uptime() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.uptime)
  return _internal_uptime();
}
inline void CMsgServerNetworkStats::_internal_set_uptime(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.uptime_ = value;
}
inline void CMsgServerNetworkStats::set_uptime(int32_t value) {
  _internal_set_uptime(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.uptime)
}

// optional int32 spawn_count = 6;
inline bool CMsgServerNetworkStats::_internal_has_spawn_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_spawn_count() const {
  return _internal_has_spawn_count();
}
inline void CMsgServerNetworkStats::clear_spawn_count() {
  _impl_.spawn_count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CMsgServerNetworkStats::_internal_spawn_count() const {
  return _impl_.spawn_count_;
}
inline int32_t CMsgServerNetworkStats::spawn_count() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.spawn_count)
  return _internal_spawn_count();
}
inline void CMsgServerNetworkStats::_internal_set_spawn_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.spawn_count_ = value;
}
inline void CMsgServerNetworkStats::set_spawn_count(int32_t value) {
  _internal_set_spawn_count(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.spawn_count)
}

// optional int32 num_clients = 8;
inline bool CMsgServerNetworkStats::_internal_has_num_clients() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_num_clients() const {
  return _internal_has_num_clients();
}
inline void CMsgServerNetworkStats::clear_num_clients() {
  _impl_.num_clients_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t CMsgServerNetworkStats::_internal_num_clients() const {
  return _impl_.num_clients_;
}
inline int32_t CMsgServerNetworkStats::num_clients() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.num_clients)
  return _internal_num_clients();
}
inline void CMsgServerNetworkStats::_internal_set_num_clients(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.num_clients_ = value;
}
inline void CMsgServerNetworkStats::set_num_clients(int32_t value) {
  _internal_set_num_clients(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.num_clients)
}

// optional int32 num_bots = 9;
inline bool CMsgServerNetworkStats::_internal_has_num_bots() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_num_bots() const {
  return _internal_has_num_bots();
}
inline void CMsgServerNetworkStats::clear_num_bots() {
  _impl_.num_bots_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t CMsgServerNetworkStats::_internal_num_bots() const {
  return _impl_.num_bots_;
}
inline int32_t CMsgServerNetworkStats::num_bots() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.num_bots)
  return _internal_num_bots();
}
inline void CMsgServerNetworkStats::_internal_set_num_bots(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.num_bots_ = value;
}
inline void CMsgServerNetworkStats::set_num_bots(int32_t value) {
  _internal_set_num_bots(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.num_bots)
}

// optional int32 num_spectators = 10;
inline bool CMsgServerNetworkStats::_internal_has_num_spectators() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_num_spectators() const {
  return _internal_has_num_spectators();
}
inline void CMsgServerNetworkStats::clear_num_spectators() {
  _impl_.num_spectators_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int32_t CMsgServerNetworkStats::_internal_num_spectators() const {
  return _impl_.num_spectators_;
}
inline int32_t CMsgServerNetworkStats::num_spectators() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.num_spectators)
  return _internal_num_spectators();
}
inline void CMsgServerNetworkStats::_internal_set_num_spectators(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.num_spectators_ = value;
}
inline void CMsgServerNetworkStats::set_num_spectators(int32_t value) {
  _internal_set_num_spectators(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.num_spectators)
}

// optional int32 num_tv_relays = 11;
inline bool CMsgServerNetworkStats::_internal_has_num_tv_relays() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_num_tv_relays() const {
  return _internal_has_num_tv_relays();
}
inline void CMsgServerNetworkStats::clear_num_tv_relays() {
  _impl_.num_tv_relays_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t CMsgServerNetworkStats::_internal_num_tv_relays() const {
  return _impl_.num_tv_relays_;
}
inline int32_t CMsgServerNetworkStats::num_tv_relays() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.num_tv_relays)
  return _internal_num_tv_relays();
}
inline void CMsgServerNetworkStats::_internal_set_num_tv_relays(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.num_tv_relays_ = value;
}
inline void CMsgServerNetworkStats::set_num_tv_relays(int32_t value) {
  _internal_set_num_tv_relays(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.num_tv_relays)
}

// optional float fps = 12;
inline bool CMsgServerNetworkStats::_internal_has_fps() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_fps() const {
  return _internal_has_fps();
}
inline void CMsgServerNetworkStats::clear_fps() {
  _impl_.fps_ = 0;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline float CMsgServerNetworkStats::_internal_fps() const {
  return _impl_.fps_;
}
inline float CMsgServerNetworkStats::fps() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.fps)
  return _internal_fps();
}
inline void CMsgServerNetworkStats::_internal_set_fps(float value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.fps_ = value;
}
inline void CMsgServerNetworkStats::set_fps(float value) {
  _internal_set_fps(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.fps)
}

// repeated .CMsgServerNetworkStats.Port ports = 17;
inline int CMsgServerNetworkStats::_internal_ports_size() const {
  return _impl_.ports_.size();
}
inline int CMsgServerNetworkStats::ports_size() const {
  return _internal_ports_size();
}
inline void CMsgServerNetworkStats::clear_ports() {
  _impl_.ports_.Clear();
}
inline ::CMsgServerNetworkStats_Port* CMsgServerNetworkStats::mutable_ports(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgServerNetworkStats.ports)
  return _impl_.ports_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerNetworkStats_Port >*
CMsgServerNetworkStats::mutable_ports() {
  // @@protoc_insertion_point(field_mutable_list:CMsgServerNetworkStats.ports)
  return &_impl_.ports_;
}
inline const ::CMsgServerNetworkStats_Port& CMsgServerNetworkStats::_internal_ports(int index) const {
  return _impl_.ports_.Get(index);
}
inline const ::CMsgServerNetworkStats_Port& CMsgServerNetworkStats::ports(int index) const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.ports)
  return _internal_ports(index);
}
inline ::CMsgServerNetworkStats_Port* CMsgServerNetworkStats::_internal_add_ports() {
  return _impl_.ports_.Add();
}
inline ::CMsgServerNetworkStats_Port* CMsgServerNetworkStats::add_ports() {
  ::CMsgServerNetworkStats_Port* _add = _internal_add_ports();
  // @@protoc_insertion_point(field_add:CMsgServerNetworkStats.ports)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerNetworkStats_Port >&
CMsgServerNetworkStats::ports() const {
  // @@protoc_insertion_point(field_list:CMsgServerNetworkStats.ports)
  return _impl_.ports_;
}

// optional float avg_ping_ms = 18;
inline bool CMsgServerNetworkStats::_internal_has_avg_ping_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_avg_ping_ms() const {
  return _internal_has_avg_ping_ms();
}
inline void CMsgServerNetworkStats::clear_avg_ping_ms() {
  _impl_.avg_ping_ms_ = 0;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline float CMsgServerNetworkStats::_internal_avg_ping_ms() const {
  return _impl_.avg_ping_ms_;
}
inline float CMsgServerNetworkStats::avg_ping_ms() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.avg_ping_ms)
  return _internal_avg_ping_ms();
}
inline void CMsgServerNetworkStats::_internal_set_avg_ping_ms(float value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.avg_ping_ms_ = value;
}
inline void CMsgServerNetworkStats::set_avg_ping_ms(float value) {
  _internal_set_avg_ping_ms(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.avg_ping_ms)
}

// optional float avg_engine_latency_out = 19;
inline bool CMsgServerNetworkStats::_internal_has_avg_engine_latency_out() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_avg_engine_latency_out() const {
  return _internal_has_avg_engine_latency_out();
}
inline void CMsgServerNetworkStats::clear_avg_engine_latency_out() {
  _impl_.avg_engine_latency_out_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline float CMsgServerNetworkStats::_internal_avg_engine_latency_out() const {
  return _impl_.avg_engine_latency_out_;
}
inline float CMsgServerNetworkStats::avg_engine_latency_out() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.avg_engine_latency_out)
  return _internal_avg_engine_latency_out();
}
inline void CMsgServerNetworkStats::_internal_set_avg_engine_latency_out(float value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.avg_engine_latency_out_ = value;
}
inline void CMsgServerNetworkStats::set_avg_engine_latency_out(float value) {
  _internal_set_avg_engine_latency_out(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.avg_engine_latency_out)
}

// optional float avg_packets_out = 20;
inline bool CMsgServerNetworkStats::_internal_has_avg_packets_out() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_avg_packets_out() const {
  return _internal_has_avg_packets_out();
}
inline void CMsgServerNetworkStats::clear_avg_packets_out() {
  _impl_.avg_packets_out_ = 0;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline float CMsgServerNetworkStats::_internal_avg_packets_out() const {
  return _impl_.avg_packets_out_;
}
inline float CMsgServerNetworkStats::avg_packets_out() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.avg_packets_out)
  return _internal_avg_packets_out();
}
inline void CMsgServerNetworkStats::_internal_set_avg_packets_out(float value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.avg_packets_out_ = value;
}
inline void CMsgServerNetworkStats::set_avg_packets_out(float value) {
  _internal_set_avg_packets_out(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.avg_packets_out)
}

// optional float avg_packets_in = 21;
inline bool CMsgServerNetworkStats::_internal_has_avg_packets_in() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_avg_packets_in() const {
  return _internal_has_avg_packets_in();
}
inline void CMsgServerNetworkStats::clear_avg_packets_in() {
  _impl_.avg_packets_in_ = 0;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline float CMsgServerNetworkStats::_internal_avg_packets_in() const {
  return _impl_.avg_packets_in_;
}
inline float CMsgServerNetworkStats::avg_packets_in() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.avg_packets_in)
  return _internal_avg_packets_in();
}
inline void CMsgServerNetworkStats::_internal_set_avg_packets_in(float value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.avg_packets_in_ = value;
}
inline void CMsgServerNetworkStats::set_avg_packets_in(float value) {
  _internal_set_avg_packets_in(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.avg_packets_in)
}

// optional float avg_loss_out = 22;
inline bool CMsgServerNetworkStats::_internal_has_avg_loss_out() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_avg_loss_out() const {
  return _internal_has_avg_loss_out();
}
inline void CMsgServerNetworkStats::clear_avg_loss_out() {
  _impl_.avg_loss_out_ = 0;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline float CMsgServerNetworkStats::_internal_avg_loss_out() const {
  return _impl_.avg_loss_out_;
}
inline float CMsgServerNetworkStats::avg_loss_out() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.avg_loss_out)
  return _internal_avg_loss_out();
}
inline void CMsgServerNetworkStats::_internal_set_avg_loss_out(float value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.avg_loss_out_ = value;
}
inline void CMsgServerNetworkStats::set_avg_loss_out(float value) {
  _internal_set_avg_loss_out(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.avg_loss_out)
}

// optional float avg_loss_in = 23;
inline bool CMsgServerNetworkStats::_internal_has_avg_loss_in() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_avg_loss_in() const {
  return _internal_has_avg_loss_in();
}
inline void CMsgServerNetworkStats::clear_avg_loss_in() {
  _impl_.avg_loss_in_ = 0;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline float CMsgServerNetworkStats::_internal_avg_loss_in() const {
  return _impl_.avg_loss_in_;
}
inline float CMsgServerNetworkStats::avg_loss_in() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.avg_loss_in)
  return _internal_avg_loss_in();
}
inline void CMsgServerNetworkStats::_internal_set_avg_loss_in(float value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.avg_loss_in_ = value;
}
inline void CMsgServerNetworkStats::set_avg_loss_in(float value) {
  _internal_set_avg_loss_in(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.avg_loss_in)
}

// optional float avg_data_out = 24;
inline bool CMsgServerNetworkStats::_internal_has_avg_data_out() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_avg_data_out() const {
  return _internal_has_avg_data_out();
}
inline void CMsgServerNetworkStats::clear_avg_data_out() {
  _impl_.avg_data_out_ = 0;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline float CMsgServerNetworkStats::_internal_avg_data_out() const {
  return _impl_.avg_data_out_;
}
inline float CMsgServerNetworkStats::avg_data_out() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.avg_data_out)
  return _internal_avg_data_out();
}
inline void CMsgServerNetworkStats::_internal_set_avg_data_out(float value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.avg_data_out_ = value;
}
inline void CMsgServerNetworkStats::set_avg_data_out(float value) {
  _internal_set_avg_data_out(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.avg_data_out)
}

// optional float avg_data_in = 25;
inline bool CMsgServerNetworkStats::_internal_has_avg_data_in() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_avg_data_in() const {
  return _internal_has_avg_data_in();
}
inline void CMsgServerNetworkStats::clear_avg_data_in() {
  _impl_.avg_data_in_ = 0;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline float CMsgServerNetworkStats::_internal_avg_data_in() const {
  return _impl_.avg_data_in_;
}
inline float CMsgServerNetworkStats::avg_data_in() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.avg_data_in)
  return _internal_avg_data_in();
}
inline void CMsgServerNetworkStats::_internal_set_avg_data_in(float value) {
  _impl_._has_bits_[0] |= 0x00400000u;
  _impl_.avg_data_in_ = value;
}
inline void CMsgServerNetworkStats::set_avg_data_in(float value) {
  _internal_set_avg_data_in(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.avg_data_in)
}

// optional uint64 total_data_in = 26;
inline bool CMsgServerNetworkStats::_internal_has_total_data_in() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_total_data_in() const {
  return _internal_has_total_data_in();
}
inline void CMsgServerNetworkStats::clear_total_data_in() {
  _impl_.total_data_in_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline uint64_t CMsgServerNetworkStats::_internal_total_data_in() const {
  return _impl_.total_data_in_;
}
inline uint64_t CMsgServerNetworkStats::total_data_in() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.total_data_in)
  return _internal_total_data_in();
}
inline void CMsgServerNetworkStats::_internal_set_total_data_in(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.total_data_in_ = value;
}
inline void CMsgServerNetworkStats::set_total_data_in(uint64_t value) {
  _internal_set_total_data_in(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.total_data_in)
}

// optional uint64 total_packets_in = 27;
inline bool CMsgServerNetworkStats::_internal_has_total_packets_in() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_total_packets_in() const {
  return _internal_has_total_packets_in();
}
inline void CMsgServerNetworkStats::clear_total_packets_in() {
  _impl_.total_packets_in_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline uint64_t CMsgServerNetworkStats::_internal_total_packets_in() const {
  return _impl_.total_packets_in_;
}
inline uint64_t CMsgServerNetworkStats::total_packets_in() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.total_packets_in)
  return _internal_total_packets_in();
}
inline void CMsgServerNetworkStats::_internal_set_total_packets_in(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.total_packets_in_ = value;
}
inline void CMsgServerNetworkStats::set_total_packets_in(uint64_t value) {
  _internal_set_total_packets_in(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.total_packets_in)
}

// optional uint64 total_data_out = 28;
inline bool CMsgServerNetworkStats::_internal_has_total_data_out() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_total_data_out() const {
  return _internal_has_total_data_out();
}
inline void CMsgServerNetworkStats::clear_total_data_out() {
  _impl_.total_data_out_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline uint64_t CMsgServerNetworkStats::_internal_total_data_out() const {
  return _impl_.total_data_out_;
}
inline uint64_t CMsgServerNetworkStats::total_data_out() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.total_data_out)
  return _internal_total_data_out();
}
inline void CMsgServerNetworkStats::_internal_set_total_data_out(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.total_data_out_ = value;
}
inline void CMsgServerNetworkStats::set_total_data_out(uint64_t value) {
  _internal_set_total_data_out(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.total_data_out)
}

// optional uint64 total_packets_out = 29;
inline bool CMsgServerNetworkStats::_internal_has_total_packets_out() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool CMsgServerNetworkStats::has_total_packets_out() const {
  return _internal_has_total_packets_out();
}
inline void CMsgServerNetworkStats::clear_total_packets_out() {
  _impl_.total_packets_out_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline uint64_t CMsgServerNetworkStats::_internal_total_packets_out() const {
  return _impl_.total_packets_out_;
}
inline uint64_t CMsgServerNetworkStats::total_packets_out() const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.total_packets_out)
  return _internal_total_packets_out();
}
inline void CMsgServerNetworkStats::_internal_set_total_packets_out(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.total_packets_out_ = value;
}
inline void CMsgServerNetworkStats::set_total_packets_out(uint64_t value) {
  _internal_set_total_packets_out(value);
  // @@protoc_insertion_point(field_set:CMsgServerNetworkStats.total_packets_out)
}

// repeated .CMsgServerNetworkStats.Player players = 30;
inline int CMsgServerNetworkStats::_internal_players_size() const {
  return _impl_.players_.size();
}
inline int CMsgServerNetworkStats::players_size() const {
  return _internal_players_size();
}
inline void CMsgServerNetworkStats::clear_players() {
  _impl_.players_.Clear();
}
inline ::CMsgServerNetworkStats_Player* CMsgServerNetworkStats::mutable_players(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgServerNetworkStats.players)
  return _impl_.players_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerNetworkStats_Player >*
CMsgServerNetworkStats::mutable_players() {
  // @@protoc_insertion_point(field_mutable_list:CMsgServerNetworkStats.players)
  return &_impl_.players_;
}
inline const ::CMsgServerNetworkStats_Player& CMsgServerNetworkStats::_internal_players(int index) const {
  return _impl_.players_.Get(index);
}
inline const ::CMsgServerNetworkStats_Player& CMsgServerNetworkStats::players(int index) const {
  // @@protoc_insertion_point(field_get:CMsgServerNetworkStats.players)
  return _internal_players(index);
}
inline ::CMsgServerNetworkStats_Player* CMsgServerNetworkStats::_internal_add_players() {
  return _impl_.players_.Add();
}
inline ::CMsgServerNetworkStats_Player* CMsgServerNetworkStats::add_players() {
  ::CMsgServerNetworkStats_Player* _add = _internal_add_players();
  // @@protoc_insertion_point(field_add:CMsgServerNetworkStats.players)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerNetworkStats_Player >&
CMsgServerNetworkStats::players() const {
  // @@protoc_insertion_point(field_list:CMsgServerNetworkStats.players)
  return _impl_.players_;
}

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

// CSVCMsg_HltvReplay

// optional int32 delay = 1;
inline bool CSVCMsg_HltvReplay::_internal_has_delay() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_HltvReplay::has_delay() const {
  return _internal_has_delay();
}
inline void CSVCMsg_HltvReplay::clear_delay() {
  _impl_.delay_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CSVCMsg_HltvReplay::_internal_delay() const {
  return _impl_.delay_;
}
inline int32_t CSVCMsg_HltvReplay::delay() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_HltvReplay.delay)
  return _internal_delay();
}
inline void CSVCMsg_HltvReplay::_internal_set_delay(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.delay_ = value;
}
inline void CSVCMsg_HltvReplay::set_delay(int32_t value) {
  _internal_set_delay(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_HltvReplay.delay)
}

// optional int32 primary_target = 2 [default = -1];
inline bool CSVCMsg_HltvReplay::_internal_has_primary_target() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CSVCMsg_HltvReplay::has_primary_target() const {
  return _internal_has_primary_target();
}
inline void CSVCMsg_HltvReplay::clear_primary_target() {
  _impl_.primary_target_ = -1;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t CSVCMsg_HltvReplay::_internal_primary_target() const {
  return _impl_.primary_target_;
}
inline int32_t CSVCMsg_HltvReplay::primary_target() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_HltvReplay.primary_target)
  return _internal_primary_target();
}
inline void CSVCMsg_HltvReplay::_internal_set_primary_target(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.primary_target_ = value;
}
inline void CSVCMsg_HltvReplay::set_primary_target(int32_t value) {
  _internal_set_primary_target(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_HltvReplay.primary_target)
}

// optional int32 replay_stop_at = 3;
inline bool CSVCMsg_HltvReplay::_internal_has_replay_stop_at() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_HltvReplay::has_replay_stop_at() const {
  return _internal_has_replay_stop_at();
}
inline void CSVCMsg_HltvReplay::clear_replay_stop_at() {
  _impl_.replay_stop_at_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_HltvReplay::_internal_replay_stop_at() const {
  return _impl_.replay_stop_at_;
}
inline int32_t CSVCMsg_HltvReplay::replay_stop_at() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_HltvReplay.replay_stop_at)
  return _internal_replay_stop_at();
}
inline void CSVCMsg_HltvReplay::_internal_set_replay_stop_at(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.replay_stop_at_ = value;
}
inline void CSVCMsg_HltvReplay::set_replay_stop_at(int32_t value) {
  _internal_set_replay_stop_at(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_HltvReplay.replay_stop_at)
}

// optional int32 replay_start_at = 4;
inline bool CSVCMsg_HltvReplay::_internal_has_replay_start_at() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_HltvReplay::has_replay_start_at() const {
  return _internal_has_replay_start_at();
}
inline void CSVCMsg_HltvReplay::clear_replay_start_at() {
  _impl_.replay_start_at_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CSVCMsg_HltvReplay::_internal_replay_start_at() const {
  return _impl_.replay_start_at_;
}
inline int32_t CSVCMsg_HltvReplay::replay_start_at() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_HltvReplay.replay_start_at)
  return _internal_replay_start_at();
}
inline void CSVCMsg_HltvReplay::_internal_set_replay_start_at(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.replay_start_at_ = value;
}
inline void CSVCMsg_HltvReplay::set_replay_start_at(int32_t value) {
  _internal_set_replay_start_at(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_HltvReplay.replay_start_at)
}

// optional int32 replay_slowdown_begin = 5;
inline bool CSVCMsg_HltvReplay::_internal_has_replay_slowdown_begin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSVCMsg_HltvReplay::has_replay_slowdown_begin() const {
  return _internal_has_replay_slowdown_begin();
}
inline void CSVCMsg_HltvReplay::clear_replay_slowdown_begin() {
  _impl_.replay_slowdown_begin_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CSVCMsg_HltvReplay::_internal_replay_slowdown_begin() const {
  return _impl_.replay_slowdown_begin_;
}
inline int32_t CSVCMsg_HltvReplay::replay_slowdown_begin() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_HltvReplay.replay_slowdown_begin)
  return _internal_replay_slowdown_begin();
}
inline void CSVCMsg_HltvReplay::_internal_set_replay_slowdown_begin(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.replay_slowdown_begin_ = value;
}
inline void CSVCMsg_HltvReplay::set_replay_slowdown_begin(int32_t value) {
  _internal_set_replay_slowdown_begin(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_HltvReplay.replay_slowdown_begin)
}

// optional int32 replay_slowdown_end = 6;
inline bool CSVCMsg_HltvReplay::_internal_has_replay_slowdown_end() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSVCMsg_HltvReplay::has_replay_slowdown_end() const {
  return _internal_has_replay_slowdown_end();
}
inline void CSVCMsg_HltvReplay::clear_replay_slowdown_end() {
  _impl_.replay_slowdown_end_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CSVCMsg_HltvReplay::_internal_replay_slowdown_end() const {
  return _impl_.replay_slowdown_end_;
}
inline int32_t CSVCMsg_HltvReplay::replay_slowdown_end() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_HltvReplay.replay_slowdown_end)
  return _internal_replay_slowdown_end();
}
inline void CSVCMsg_HltvReplay::_internal_set_replay_slowdown_end(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.replay_slowdown_end_ = value;
}
inline void CSVCMsg_HltvReplay::set_replay_slowdown_end(int32_t value) {
  _internal_set_replay_slowdown_end(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_HltvReplay.replay_slowdown_end)
}

// optional float replay_slowdown_rate = 7;
inline bool CSVCMsg_HltvReplay::_internal_has_replay_slowdown_rate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CSVCMsg_HltvReplay::has_replay_slowdown_rate() const {
  return _internal_has_replay_slowdown_rate();
}
inline void CSVCMsg_HltvReplay::clear_replay_slowdown_rate() {
  _impl_.replay_slowdown_rate_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float CSVCMsg_HltvReplay::_internal_replay_slowdown_rate() const {
  return _impl_.replay_slowdown_rate_;
}
inline float CSVCMsg_HltvReplay::replay_slowdown_rate() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_HltvReplay.replay_slowdown_rate)
  return _internal_replay_slowdown_rate();
}
inline void CSVCMsg_HltvReplay::_internal_set_replay_slowdown_rate(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.replay_slowdown_rate_ = value;
}
inline void CSVCMsg_HltvReplay::set_replay_slowdown_rate(float value) {
  _internal_set_replay_slowdown_rate(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_HltvReplay.replay_slowdown_rate)
}

// optional int32 reason = 8;
inline bool CSVCMsg_HltvReplay::_internal_has_reason() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CSVCMsg_HltvReplay::has_reason() const {
  return _internal_has_reason();
}
inline void CSVCMsg_HltvReplay::clear_reason() {
  _impl_.reason_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t CSVCMsg_HltvReplay::_internal_reason() const {
  return _impl_.reason_;
}
inline int32_t CSVCMsg_HltvReplay::reason() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_HltvReplay.reason)
  return _internal_reason();
}
inline void CSVCMsg_HltvReplay::_internal_set_reason(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.reason_ = value;
}
inline void CSVCMsg_HltvReplay::set_reason(int32_t value) {
  _internal_set_reason(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_HltvReplay.reason)
}

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

// CCLCMsg_HltvReplay

// optional int32 request = 1;
inline bool CCLCMsg_HltvReplay::_internal_has_request() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CCLCMsg_HltvReplay::has_request() const {
  return _internal_has_request();
}
inline void CCLCMsg_HltvReplay::clear_request() {
  _impl_.request_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CCLCMsg_HltvReplay::_internal_request() const {
  return _impl_.request_;
}
inline int32_t CCLCMsg_HltvReplay::request() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_HltvReplay.request)
  return _internal_request();
}
inline void CCLCMsg_HltvReplay::_internal_set_request(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.request_ = value;
}
inline void CCLCMsg_HltvReplay::set_request(int32_t value) {
  _internal_set_request(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_HltvReplay.request)
}

// optional float slowdown_length = 2;
inline bool CCLCMsg_HltvReplay::_internal_has_slowdown_length() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CCLCMsg_HltvReplay::has_slowdown_length() const {
  return _internal_has_slowdown_length();
}
inline void CCLCMsg_HltvReplay::clear_slowdown_length() {
  _impl_.slowdown_length_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CCLCMsg_HltvReplay::_internal_slowdown_length() const {
  return _impl_.slowdown_length_;
}
inline float CCLCMsg_HltvReplay::slowdown_length() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_HltvReplay.slowdown_length)
  return _internal_slowdown_length();
}
inline void CCLCMsg_HltvReplay::_internal_set_slowdown_length(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.slowdown_length_ = value;
}
inline void CCLCMsg_HltvReplay::set_slowdown_length(float value) {
  _internal_set_slowdown_length(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_HltvReplay.slowdown_length)
}

// optional float slowdown_rate = 3;
inline bool CCLCMsg_HltvReplay::_internal_has_slowdown_rate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CCLCMsg_HltvReplay::has_slowdown_rate() const {
  return _internal_has_slowdown_rate();
}
inline void CCLCMsg_HltvReplay::clear_slowdown_rate() {
  _impl_.slowdown_rate_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CCLCMsg_HltvReplay::_internal_slowdown_rate() const {
  return _impl_.slowdown_rate_;
}
inline float CCLCMsg_HltvReplay::slowdown_rate() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_HltvReplay.slowdown_rate)
  return _internal_slowdown_rate();
}
inline void CCLCMsg_HltvReplay::_internal_set_slowdown_rate(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.slowdown_rate_ = value;
}
inline void CCLCMsg_HltvReplay::set_slowdown_rate(float value) {
  _internal_set_slowdown_rate(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_HltvReplay.slowdown_rate)
}

// optional int32 primary_target = 4 [default = -1];
inline bool CCLCMsg_HltvReplay::_internal_has_primary_target() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CCLCMsg_HltvReplay::has_primary_target() const {
  return _internal_has_primary_target();
}
inline void CCLCMsg_HltvReplay::clear_primary_target() {
  _impl_.primary_target_ = -1;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CCLCMsg_HltvReplay::_internal_primary_target() const {
  return _impl_.primary_target_;
}
inline int32_t CCLCMsg_HltvReplay::primary_target() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_HltvReplay.primary_target)
  return _internal_primary_target();
}
inline void CCLCMsg_HltvReplay::_internal_set_primary_target(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.primary_target_ = value;
}
inline void CCLCMsg_HltvReplay::set_primary_target(int32_t value) {
  _internal_set_primary_target(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_HltvReplay.primary_target)
}

// optional float event_time = 5;
inline bool CCLCMsg_HltvReplay::_internal_has_event_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CCLCMsg_HltvReplay::has_event_time() const {
  return _internal_has_event_time();
}
inline void CCLCMsg_HltvReplay::clear_event_time() {
  _impl_.event_time_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float CCLCMsg_HltvReplay::_internal_event_time() const {
  return _impl_.event_time_;
}
inline float CCLCMsg_HltvReplay::event_time() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_HltvReplay.event_time)
  return _internal_event_time();
}
inline void CCLCMsg_HltvReplay::_internal_set_event_time(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.event_time_ = value;
}
inline void CCLCMsg_HltvReplay::set_event_time(float value) {
  _internal_set_event_time(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_HltvReplay.event_time)
}

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

// CSVCMsg_Broadcast_Command

// optional string cmd = 1;
inline bool CSVCMsg_Broadcast_Command::_internal_has_cmd() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_Broadcast_Command::has_cmd() const {
  return _internal_has_cmd();
}
inline void CSVCMsg_Broadcast_Command::clear_cmd() {
  _impl_.cmd_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_Broadcast_Command::cmd() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_Broadcast_Command.cmd)
  return _internal_cmd();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_Broadcast_Command::set_cmd(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.cmd_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_Broadcast_Command.cmd)
}
inline std::string* CSVCMsg_Broadcast_Command::mutable_cmd() {
  std::string* _s = _internal_mutable_cmd();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_Broadcast_Command.cmd)
  return _s;
}
inline const std::string& CSVCMsg_Broadcast_Command::_internal_cmd() const {
  return _impl_.cmd_.Get();
}
inline void CSVCMsg_Broadcast_Command::_internal_set_cmd(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.cmd_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_Broadcast_Command::_internal_mutable_cmd() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.cmd_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_Broadcast_Command::release_cmd() {
  // @@protoc_insertion_point(field_release:CSVCMsg_Broadcast_Command.cmd)
  if (!_internal_has_cmd()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.cmd_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.cmd_.IsDefault()) {
    _impl_.cmd_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_Broadcast_Command::set_allocated_cmd(std::string* cmd) {
  if (cmd != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.cmd_.SetAllocated(cmd, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.cmd_.IsDefault()) {
    _impl_.cmd_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_Broadcast_Command.cmd)
}

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

// CCLCMsg_HltvFixupOperatorTick

// optional int32 tick = 1;
inline bool CCLCMsg_HltvFixupOperatorTick::_internal_has_tick() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CCLCMsg_HltvFixupOperatorTick::has_tick() const {
  return _internal_has_tick();
}
inline void CCLCMsg_HltvFixupOperatorTick::clear_tick() {
  _impl_.tick_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CCLCMsg_HltvFixupOperatorTick::_internal_tick() const {
  return _impl_.tick_;
}
inline int32_t CCLCMsg_HltvFixupOperatorTick::tick() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_HltvFixupOperatorTick.tick)
  return _internal_tick();
}
inline void CCLCMsg_HltvFixupOperatorTick::_internal_set_tick(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.tick_ = value;
}
inline void CCLCMsg_HltvFixupOperatorTick::set_tick(int32_t value) {
  _internal_set_tick(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_HltvFixupOperatorTick.tick)
}

// optional bytes props_data = 2;
inline bool CCLCMsg_HltvFixupOperatorTick::_internal_has_props_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CCLCMsg_HltvFixupOperatorTick::has_props_data() const {
  return _internal_has_props_data();
}
inline void CCLCMsg_HltvFixupOperatorTick::clear_props_data() {
  _impl_.props_data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CCLCMsg_HltvFixupOperatorTick::props_data() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_HltvFixupOperatorTick.props_data)
  return _internal_props_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CCLCMsg_HltvFixupOperatorTick::set_props_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.props_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CCLCMsg_HltvFixupOperatorTick.props_data)
}
inline std::string* CCLCMsg_HltvFixupOperatorTick::mutable_props_data() {
  std::string* _s = _internal_mutable_props_data();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_HltvFixupOperatorTick.props_data)
  return _s;
}
inline const std::string& CCLCMsg_HltvFixupOperatorTick::_internal_props_data() const {
  return _impl_.props_data_.Get();
}
inline void CCLCMsg_HltvFixupOperatorTick::_internal_set_props_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.props_data_.Set(value, GetArenaForAllocation());
}
inline std::string* CCLCMsg_HltvFixupOperatorTick::_internal_mutable_props_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.props_data_.Mutable(GetArenaForAllocation());
}
inline std::string* CCLCMsg_HltvFixupOperatorTick::release_props_data() {
  // @@protoc_insertion_point(field_release:CCLCMsg_HltvFixupOperatorTick.props_data)
  if (!_internal_has_props_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.props_data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.props_data_.IsDefault()) {
    _impl_.props_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CCLCMsg_HltvFixupOperatorTick::set_allocated_props_data(std::string* props_data) {
  if (props_data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.props_data_.SetAllocated(props_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.props_data_.IsDefault()) {
    _impl_.props_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_HltvFixupOperatorTick.props_data)
}

// optional .CMsgVector origin = 3;
inline bool CCLCMsg_HltvFixupOperatorTick::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CCLCMsg_HltvFixupOperatorTick::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CCLCMsg_HltvFixupOperatorTick::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CCLCMsg_HltvFixupOperatorTick::origin() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_HltvFixupOperatorTick.origin)
  return _internal_origin();
}
inline void CCLCMsg_HltvFixupOperatorTick::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CCLCMsg_HltvFixupOperatorTick.origin)
}
inline ::CMsgVector* CCLCMsg_HltvFixupOperatorTick::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CCLCMsg_HltvFixupOperatorTick::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CCLCMsg_HltvFixupOperatorTick.origin)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CCLCMsg_HltvFixupOperatorTick::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CCLCMsg_HltvFixupOperatorTick::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_HltvFixupOperatorTick.origin)
  return _msg;
}
inline void CCLCMsg_HltvFixupOperatorTick::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_HltvFixupOperatorTick.origin)
}

// optional .CMsgQAngle eye_angles = 4;
inline bool CCLCMsg_HltvFixupOperatorTick::_internal_has_eye_angles() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.eye_angles_ != nullptr);
  return value;
}
inline bool CCLCMsg_HltvFixupOperatorTick::has_eye_angles() const {
  return _internal_has_eye_angles();
}
inline const ::CMsgQAngle& CCLCMsg_HltvFixupOperatorTick::_internal_eye_angles() const {
  const ::CMsgQAngle* p = _impl_.eye_angles_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQAngle&>(
      ::_CMsgQAngle_default_instance_);
}
inline const ::CMsgQAngle& CCLCMsg_HltvFixupOperatorTick::eye_angles() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_HltvFixupOperatorTick.eye_angles)
  return _internal_eye_angles();
}
inline void CCLCMsg_HltvFixupOperatorTick::unsafe_arena_set_allocated_eye_angles(
    ::CMsgQAngle* eye_angles) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.eye_angles_);
  }
  _impl_.eye_angles_ = eye_angles;
  if (eye_angles) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CCLCMsg_HltvFixupOperatorTick.eye_angles)
}
inline ::CMsgQAngle* CCLCMsg_HltvFixupOperatorTick::release_eye_angles() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgQAngle* temp = _impl_.eye_angles_;
  _impl_.eye_angles_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgQAngle* CCLCMsg_HltvFixupOperatorTick::unsafe_arena_release_eye_angles() {
  // @@protoc_insertion_point(field_release:CCLCMsg_HltvFixupOperatorTick.eye_angles)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgQAngle* temp = _impl_.eye_angles_;
  _impl_.eye_angles_ = nullptr;
  return temp;
}
inline ::CMsgQAngle* CCLCMsg_HltvFixupOperatorTick::_internal_mutable_eye_angles() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.eye_angles_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgQAngle>(GetArenaForAllocation());
    _impl_.eye_angles_ = p;
  }
  return _impl_.eye_angles_;
}
inline ::CMsgQAngle* CCLCMsg_HltvFixupOperatorTick::mutable_eye_angles() {
  ::CMsgQAngle* _msg = _internal_mutable_eye_angles();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_HltvFixupOperatorTick.eye_angles)
  return _msg;
}
inline void CCLCMsg_HltvFixupOperatorTick::set_allocated_eye_angles(::CMsgQAngle* eye_angles) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.eye_angles_);
  }
  if (eye_angles) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(eye_angles));
    if (message_arena != submessage_arena) {
      eye_angles = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, eye_angles, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.eye_angles_ = eye_angles;
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_HltvFixupOperatorTick.eye_angles)
}

// optional int32 observer_mode = 5;
inline bool CCLCMsg_HltvFixupOperatorTick::_internal_has_observer_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CCLCMsg_HltvFixupOperatorTick::has_observer_mode() const {
  return _internal_has_observer_mode();
}
inline void CCLCMsg_HltvFixupOperatorTick::clear_observer_mode() {
  _impl_.observer_mode_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CCLCMsg_HltvFixupOperatorTick::_internal_observer_mode() const {
  return _impl_.observer_mode_;
}
inline int32_t CCLCMsg_HltvFixupOperatorTick::observer_mode() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_HltvFixupOperatorTick.observer_mode)
  return _internal_observer_mode();
}
inline void CCLCMsg_HltvFixupOperatorTick::_internal_set_observer_mode(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.observer_mode_ = value;
}
inline void CCLCMsg_HltvFixupOperatorTick::set_observer_mode(int32_t value) {
  _internal_set_observer_mode(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_HltvFixupOperatorTick.observer_mode)
}

// optional bool cameraman_scoreboard = 6;
inline bool CCLCMsg_HltvFixupOperatorTick::_internal_has_cameraman_scoreboard() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CCLCMsg_HltvFixupOperatorTick::has_cameraman_scoreboard() const {
  return _internal_has_cameraman_scoreboard();
}
inline void CCLCMsg_HltvFixupOperatorTick::clear_cameraman_scoreboard() {
  _impl_.cameraman_scoreboard_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool CCLCMsg_HltvFixupOperatorTick::_internal_cameraman_scoreboard() const {
  return _impl_.cameraman_scoreboard_;
}
inline bool CCLCMsg_HltvFixupOperatorTick::cameraman_scoreboard() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_HltvFixupOperatorTick.cameraman_scoreboard)
  return _internal_cameraman_scoreboard();
}
inline void CCLCMsg_HltvFixupOperatorTick::_internal_set_cameraman_scoreboard(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.cameraman_scoreboard_ = value;
}
inline void CCLCMsg_HltvFixupOperatorTick::set_cameraman_scoreboard(bool value) {
  _internal_set_cameraman_scoreboard(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_HltvFixupOperatorTick.cameraman_scoreboard)
}

// optional int32 observer_target = 7;
inline bool CCLCMsg_HltvFixupOperatorTick::_internal_has_observer_target() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CCLCMsg_HltvFixupOperatorTick::has_observer_target() const {
  return _internal_has_observer_target();
}
inline void CCLCMsg_HltvFixupOperatorTick::clear_observer_target() {
  _impl_.observer_target_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline int32_t CCLCMsg_HltvFixupOperatorTick::_internal_observer_target() const {
  return _impl_.observer_target_;
}
inline int32_t CCLCMsg_HltvFixupOperatorTick::observer_target() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_HltvFixupOperatorTick.observer_target)
  return _internal_observer_target();
}
inline void CCLCMsg_HltvFixupOperatorTick::_internal_set_observer_target(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.observer_target_ = value;
}
inline void CCLCMsg_HltvFixupOperatorTick::set_observer_target(int32_t value) {
  _internal_set_observer_target(value);
  // @@protoc_insertion_point(field_set:CCLCMsg_HltvFixupOperatorTick.observer_target)
}

// optional .CMsgVector view_offset = 8;
inline bool CCLCMsg_HltvFixupOperatorTick::_internal_has_view_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.view_offset_ != nullptr);
  return value;
}
inline bool CCLCMsg_HltvFixupOperatorTick::has_view_offset() const {
  return _internal_has_view_offset();
}
inline const ::CMsgVector& CCLCMsg_HltvFixupOperatorTick::_internal_view_offset() const {
  const ::CMsgVector* p = _impl_.view_offset_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CCLCMsg_HltvFixupOperatorTick::view_offset() const {
  // @@protoc_insertion_point(field_get:CCLCMsg_HltvFixupOperatorTick.view_offset)
  return _internal_view_offset();
}
inline void CCLCMsg_HltvFixupOperatorTick::unsafe_arena_set_allocated_view_offset(
    ::CMsgVector* view_offset) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.view_offset_);
  }
  _impl_.view_offset_ = view_offset;
  if (view_offset) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CCLCMsg_HltvFixupOperatorTick.view_offset)
}
inline ::CMsgVector* CCLCMsg_HltvFixupOperatorTick::release_view_offset() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgVector* temp = _impl_.view_offset_;
  _impl_.view_offset_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CCLCMsg_HltvFixupOperatorTick::unsafe_arena_release_view_offset() {
  // @@protoc_insertion_point(field_release:CCLCMsg_HltvFixupOperatorTick.view_offset)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgVector* temp = _impl_.view_offset_;
  _impl_.view_offset_ = nullptr;
  return temp;
}
inline ::CMsgVector* CCLCMsg_HltvFixupOperatorTick::_internal_mutable_view_offset() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.view_offset_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.view_offset_ = p;
  }
  return _impl_.view_offset_;
}
inline ::CMsgVector* CCLCMsg_HltvFixupOperatorTick::mutable_view_offset() {
  ::CMsgVector* _msg = _internal_mutable_view_offset();
  // @@protoc_insertion_point(field_mutable:CCLCMsg_HltvFixupOperatorTick.view_offset)
  return _msg;
}
inline void CCLCMsg_HltvFixupOperatorTick::set_allocated_view_offset(::CMsgVector* view_offset) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.view_offset_);
  }
  if (view_offset) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(view_offset));
    if (message_arena != submessage_arena) {
      view_offset = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, view_offset, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.view_offset_ = view_offset;
  // @@protoc_insertion_point(field_set_allocated:CCLCMsg_HltvFixupOperatorTick.view_offset)
}

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

// CSVCMsg_HltvFixupOperatorStatus

// optional uint32 mode = 1;
inline bool CSVCMsg_HltvFixupOperatorStatus::_internal_has_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_HltvFixupOperatorStatus::has_mode() const {
  return _internal_has_mode();
}
inline void CSVCMsg_HltvFixupOperatorStatus::clear_mode() {
  _impl_.mode_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CSVCMsg_HltvFixupOperatorStatus::_internal_mode() const {
  return _impl_.mode_;
}
inline uint32_t CSVCMsg_HltvFixupOperatorStatus::mode() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_HltvFixupOperatorStatus.mode)
  return _internal_mode();
}
inline void CSVCMsg_HltvFixupOperatorStatus::_internal_set_mode(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mode_ = value;
}
inline void CSVCMsg_HltvFixupOperatorStatus::set_mode(uint32_t value) {
  _internal_set_mode(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_HltvFixupOperatorStatus.mode)
}

// optional string override_operator_name = 2;
inline bool CSVCMsg_HltvFixupOperatorStatus::_internal_has_override_operator_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_HltvFixupOperatorStatus::has_override_operator_name() const {
  return _internal_has_override_operator_name();
}
inline void CSVCMsg_HltvFixupOperatorStatus::clear_override_operator_name() {
  _impl_.override_operator_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_HltvFixupOperatorStatus::override_operator_name() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_HltvFixupOperatorStatus.override_operator_name)
  return _internal_override_operator_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_HltvFixupOperatorStatus::set_override_operator_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.override_operator_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_HltvFixupOperatorStatus.override_operator_name)
}
inline std::string* CSVCMsg_HltvFixupOperatorStatus::mutable_override_operator_name() {
  std::string* _s = _internal_mutable_override_operator_name();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_HltvFixupOperatorStatus.override_operator_name)
  return _s;
}
inline const std::string& CSVCMsg_HltvFixupOperatorStatus::_internal_override_operator_name() const {
  return _impl_.override_operator_name_.Get();
}
inline void CSVCMsg_HltvFixupOperatorStatus::_internal_set_override_operator_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.override_operator_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_HltvFixupOperatorStatus::_internal_mutable_override_operator_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.override_operator_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_HltvFixupOperatorStatus::release_override_operator_name() {
  // @@protoc_insertion_point(field_release:CSVCMsg_HltvFixupOperatorStatus.override_operator_name)
  if (!_internal_has_override_operator_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.override_operator_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.override_operator_name_.IsDefault()) {
    _impl_.override_operator_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_HltvFixupOperatorStatus::set_allocated_override_operator_name(std::string* override_operator_name) {
  if (override_operator_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.override_operator_name_.SetAllocated(override_operator_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.override_operator_name_.IsDefault()) {
    _impl_.override_operator_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_HltvFixupOperatorStatus.override_operator_name)
}

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

// CMsgServerUserCmd

// optional bytes data = 1;
inline bool CMsgServerUserCmd::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgServerUserCmd::has_data() const {
  return _internal_has_data();
}
inline void CMsgServerUserCmd::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgServerUserCmd::data() const {
  // @@protoc_insertion_point(field_get:CMsgServerUserCmd.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgServerUserCmd::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgServerUserCmd.data)
}
inline std::string* CMsgServerUserCmd::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:CMsgServerUserCmd.data)
  return _s;
}
inline const std::string& CMsgServerUserCmd::_internal_data() const {
  return _impl_.data_.Get();
}
inline void CMsgServerUserCmd::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgServerUserCmd::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgServerUserCmd::release_data() {
  // @@protoc_insertion_point(field_release:CMsgServerUserCmd.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgServerUserCmd::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgServerUserCmd.data)
}

// optional int32 cmd_number = 2;
inline bool CMsgServerUserCmd::_internal_has_cmd_number() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgServerUserCmd::has_cmd_number() const {
  return _internal_has_cmd_number();
}
inline void CMsgServerUserCmd::clear_cmd_number() {
  _impl_.cmd_number_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CMsgServerUserCmd::_internal_cmd_number() const {
  return _impl_.cmd_number_;
}
inline int32_t CMsgServerUserCmd::cmd_number() const {
  // @@protoc_insertion_point(field_get:CMsgServerUserCmd.cmd_number)
  return _internal_cmd_number();
}
inline void CMsgServerUserCmd::_internal_set_cmd_number(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.cmd_number_ = value;
}
inline void CMsgServerUserCmd::set_cmd_number(int32_t value) {
  _internal_set_cmd_number(value);
  // @@protoc_insertion_point(field_set:CMsgServerUserCmd.cmd_number)
}

// optional int32 player_slot = 3 [default = -1];
inline bool CMsgServerUserCmd::_internal_has_player_slot() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgServerUserCmd::has_player_slot() const {
  return _internal_has_player_slot();
}
inline void CMsgServerUserCmd::clear_player_slot() {
  _impl_.player_slot_ = -1;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CMsgServerUserCmd::_internal_player_slot() const {
  return _impl_.player_slot_;
}
inline int32_t CMsgServerUserCmd::player_slot() const {
  // @@protoc_insertion_point(field_get:CMsgServerUserCmd.player_slot)
  return _internal_player_slot();
}
inline void CMsgServerUserCmd::_internal_set_player_slot(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.player_slot_ = value;
}
inline void CMsgServerUserCmd::set_player_slot(int32_t value) {
  _internal_set_player_slot(value);
  // @@protoc_insertion_point(field_set:CMsgServerUserCmd.player_slot)
}

// optional int32 server_tick_executed = 4;
inline bool CMsgServerUserCmd::_internal_has_server_tick_executed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgServerUserCmd::has_server_tick_executed() const {
  return _internal_has_server_tick_executed();
}
inline void CMsgServerUserCmd::clear_server_tick_executed() {
  _impl_.server_tick_executed_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CMsgServerUserCmd::_internal_server_tick_executed() const {
  return _impl_.server_tick_executed_;
}
inline int32_t CMsgServerUserCmd::server_tick_executed() const {
  // @@protoc_insertion_point(field_get:CMsgServerUserCmd.server_tick_executed)
  return _internal_server_tick_executed();
}
inline void CMsgServerUserCmd::_internal_set_server_tick_executed(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.server_tick_executed_ = value;
}
inline void CMsgServerUserCmd::set_server_tick_executed(int32_t value) {
  _internal_set_server_tick_executed(value);
  // @@protoc_insertion_point(field_set:CMsgServerUserCmd.server_tick_executed)
}

// optional int32 client_tick = 5;
inline bool CMsgServerUserCmd::_internal_has_client_tick() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgServerUserCmd::has_client_tick() const {
  return _internal_has_client_tick();
}
inline void CMsgServerUserCmd::clear_client_tick() {
  _impl_.client_tick_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CMsgServerUserCmd::_internal_client_tick() const {
  return _impl_.client_tick_;
}
inline int32_t CMsgServerUserCmd::client_tick() const {
  // @@protoc_insertion_point(field_get:CMsgServerUserCmd.client_tick)
  return _internal_client_tick();
}
inline void CMsgServerUserCmd::_internal_set_client_tick(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.client_tick_ = value;
}
inline void CMsgServerUserCmd::set_client_tick(int32_t value) {
  _internal_set_client_tick(value);
  // @@protoc_insertion_point(field_set:CMsgServerUserCmd.client_tick)
}

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

// CSVCMsg_UserCommands

// repeated .CMsgServerUserCmd commands = 1;
inline int CSVCMsg_UserCommands::_internal_commands_size() const {
  return _impl_.commands_.size();
}
inline int CSVCMsg_UserCommands::commands_size() const {
  return _internal_commands_size();
}
inline void CSVCMsg_UserCommands::clear_commands() {
  _impl_.commands_.Clear();
}
inline ::CMsgServerUserCmd* CSVCMsg_UserCommands::mutable_commands(int index) {
  // @@protoc_insertion_point(field_mutable:CSVCMsg_UserCommands.commands)
  return _impl_.commands_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerUserCmd >*
CSVCMsg_UserCommands::mutable_commands() {
  // @@protoc_insertion_point(field_mutable_list:CSVCMsg_UserCommands.commands)
  return &_impl_.commands_;
}
inline const ::CMsgServerUserCmd& CSVCMsg_UserCommands::_internal_commands(int index) const {
  return _impl_.commands_.Get(index);
}
inline const ::CMsgServerUserCmd& CSVCMsg_UserCommands::commands(int index) const {
  // @@protoc_insertion_point(field_get:CSVCMsg_UserCommands.commands)
  return _internal_commands(index);
}
inline ::CMsgServerUserCmd* CSVCMsg_UserCommands::_internal_add_commands() {
  return _impl_.commands_.Add();
}
inline ::CMsgServerUserCmd* CSVCMsg_UserCommands::add_commands() {
  ::CMsgServerUserCmd* _add = _internal_add_commands();
  // @@protoc_insertion_point(field_add:CSVCMsg_UserCommands.commands)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgServerUserCmd >&
CSVCMsg_UserCommands::commands() const {
  // @@protoc_insertion_point(field_list:CSVCMsg_UserCommands.commands)
  return _impl_.commands_;
}

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

// CSVCMsg_NextMsgPredicted

// optional int32 predicted_by_player_slot = 1 [default = -1];
inline bool CSVCMsg_NextMsgPredicted::_internal_has_predicted_by_player_slot() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_NextMsgPredicted::has_predicted_by_player_slot() const {
  return _internal_has_predicted_by_player_slot();
}
inline void CSVCMsg_NextMsgPredicted::clear_predicted_by_player_slot() {
  _impl_.predicted_by_player_slot_ = -1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_NextMsgPredicted::_internal_predicted_by_player_slot() const {
  return _impl_.predicted_by_player_slot_;
}
inline int32_t CSVCMsg_NextMsgPredicted::predicted_by_player_slot() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_NextMsgPredicted.predicted_by_player_slot)
  return _internal_predicted_by_player_slot();
}
inline void CSVCMsg_NextMsgPredicted::_internal_set_predicted_by_player_slot(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.predicted_by_player_slot_ = value;
}
inline void CSVCMsg_NextMsgPredicted::set_predicted_by_player_slot(int32_t value) {
  _internal_set_predicted_by_player_slot(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_NextMsgPredicted.predicted_by_player_slot)
}

// optional uint32 message_type_id = 2;
inline bool CSVCMsg_NextMsgPredicted::_internal_has_message_type_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_NextMsgPredicted::has_message_type_id() const {
  return _internal_has_message_type_id();
}
inline void CSVCMsg_NextMsgPredicted::clear_message_type_id() {
  _impl_.message_type_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CSVCMsg_NextMsgPredicted::_internal_message_type_id() const {
  return _impl_.message_type_id_;
}
inline uint32_t CSVCMsg_NextMsgPredicted::message_type_id() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_NextMsgPredicted.message_type_id)
  return _internal_message_type_id();
}
inline void CSVCMsg_NextMsgPredicted::_internal_set_message_type_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.message_type_id_ = value;
}
inline void CSVCMsg_NextMsgPredicted::set_message_type_id(uint32_t value) {
  _internal_set_message_type_id(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_NextMsgPredicted.message_type_id)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::CBidirMsg_PredictionEvent_ESyncType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::CBidirMsg_PredictionEvent_ESyncType>() {
  return ::CBidirMsg_PredictionEvent_ESyncType_descriptor();
}
template <> struct is_proto_enum< ::CLC_Messages> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::CLC_Messages>() {
  return ::CLC_Messages_descriptor();
}
template <> struct is_proto_enum< ::SVC_Messages> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::SVC_Messages>() {
  return ::SVC_Messages_descriptor();
}
template <> struct is_proto_enum< ::VoiceDataFormat_t> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::VoiceDataFormat_t>() {
  return ::VoiceDataFormat_t_descriptor();
}
template <> struct is_proto_enum< ::RequestPause_t> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::RequestPause_t>() {
  return ::RequestPause_t_descriptor();
}
template <> struct is_proto_enum< ::PrefetchType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::PrefetchType>() {
  return ::PrefetchType_descriptor();
}
template <> struct is_proto_enum< ::ESplitScreenMessageType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ESplitScreenMessageType>() {
  return ::ESplitScreenMessageType_descriptor();
}
template <> struct is_proto_enum< ::EQueryCvarValueStatus> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::EQueryCvarValueStatus>() {
  return ::EQueryCvarValueStatus_descriptor();
}
template <> struct is_proto_enum< ::DIALOG_TYPE> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::DIALOG_TYPE>() {
  return ::DIALOG_TYPE_descriptor();
}
template <> struct is_proto_enum< ::SVC_Messages_LowFrequency> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::SVC_Messages_LowFrequency>() {
  return ::SVC_Messages_LowFrequency_descriptor();
}
template <> struct is_proto_enum< ::Bidirectional_Messages> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Bidirectional_Messages>() {
  return ::Bidirectional_Messages_descriptor();
}
template <> struct is_proto_enum< ::Bidirectional_Messages_LowFrequency> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Bidirectional_Messages_LowFrequency>() {
  return ::Bidirectional_Messages_LowFrequency_descriptor();
}
template <> struct is_proto_enum< ::ReplayEventType_t> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ReplayEventType_t>() {
  return ::ReplayEventType_t_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_netmessages_2eproto
