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

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

#ifndef PROTOBUF_netmessages_2eproto__INCLUDED
#define PROTOBUF_netmessages_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 2004000
#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 2004001 < GOOGLE_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/generated_message_util.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_message_reflection.h>
#include "google/protobuf/descriptor.pb.h"
// @@protoc_insertion_point(includes)

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_netmessages_2eproto();
void protobuf_AssignDesc_netmessages_2eproto();
void protobuf_ShutdownFile_netmessages_2eproto();

class CMsgVector;
class CMsgVector2D;
class CMsgQAngle;
class CMsg_CVars;
class CMsg_CVars_CVar;
class CNETMsg_NOP;
class CNETMsg_Disconnect;
class CNETMsg_File;
class CNETMsg_SplitScreenUser;
class CNETMsg_Tick;
class CNETMsg_StringCmd;
class CNETMsg_SetConVar;
class CNETMsg_SignonState;
class CCLCMsg_ClientInfo;
class CCLCMsg_Move;
class CCLCMsg_VoiceData;
class CCLCMsg_BaselineAck;
class CCLCMsg_ListenEvents;
class CCLCMsg_RespondCvarValue;
class CCLCMsg_FileCRCCheck;
class CCLCMsg_LoadingProgress;
class CCLCMsg_SplitPlayerConnect;
class CCLCMsg_ClientMessage;
class CSVCMsg_ServerInfo;
class CSVCMsg_ClassInfo;
class CSVCMsg_ClassInfo_class_t;
class CSVCMsg_SetPause;
class CSVCMsg_VoiceInit;
class CSVCMsg_Print;
class CSVCMsg_Sounds;
class CSVCMsg_Sounds_sounddata_t;
class CSVCMsg_Prefetch;
class CSVCMsg_SetView;
class CSVCMsg_FixAngle;
class CSVCMsg_CrosshairAngle;
class CSVCMsg_BSPDecal;
class CSVCMsg_SplitScreen;
class CSVCMsg_GetCvarValue;
class CSVCMsg_Menu;
class CSVCMsg_SendTable;
class CSVCMsg_SendTable_sendprop_t;
class CSVCMsg_GameEvent;
class CSVCMsg_GameEvent_key_t;
class CSVCMsg_GameEventList;
class CSVCMsg_GameEventList_key_t;
class CSVCMsg_GameEventList_descriptor_t;
class CSVCMsg_PacketEntities;
class CSVCMsg_TempEntities;
class CSVCMsg_CreateStringTable;
class CSVCMsg_UpdateStringTable;
class CSVCMsg_UserMessage;
class CSVCMsg_VoiceData;
class CSVCMsgList_GameEvents;
class CSVCMsgList_GameEvents_event_t;
class CSVCMsgList_UserMessages;
class CSVCMsgList_UserMessages_usermsg_t;
class CSVCMsg_PacketReliable;

enum NET_Messages {
  net_NOP = 0,
  net_Disconnect = 1,
  net_File = 2,
  net_SplitScreenUser = 3,
  net_Tick = 4,
  net_StringCmd = 5,
  net_SetConVar = 6,
  net_SignonState = 7
};
bool NET_Messages_IsValid(int value);
const NET_Messages NET_Messages_MIN = net_NOP;
const NET_Messages NET_Messages_MAX = net_SignonState;
const int NET_Messages_ARRAYSIZE = NET_Messages_MAX + 1;

const ::google::protobuf::EnumDescriptor* NET_Messages_descriptor();
inline const ::std::string& NET_Messages_Name(NET_Messages value) {
  return ::google::protobuf::internal::NameOfEnum(
    NET_Messages_descriptor(), value);
}
inline bool NET_Messages_Parse(
    const ::std::string& name, NET_Messages* value) {
  return ::google::protobuf::internal::ParseNamedEnum<NET_Messages>(
    NET_Messages_descriptor(), name, value);
}
enum SIGNONSTATE {
  SIGNONSTATE_NONE = 0,
  SIGNONSTATE_CHALLENGE = 1,
  SIGNONSTATE_CONNECTED = 2,
  SIGNONSTATE_NEW = 3,
  SIGNONSTATE_PRESPAWN = 4,
  SIGNONSTATE_SPAWN = 5,
  SIGNONSTATE_FULL = 6,
  SIGNONSTATE_CHANGELEVEL = 7
};
bool SIGNONSTATE_IsValid(int value);
const SIGNONSTATE SIGNONSTATE_MIN = SIGNONSTATE_NONE;
const SIGNONSTATE SIGNONSTATE_MAX = SIGNONSTATE_CHANGELEVEL;
const int SIGNONSTATE_ARRAYSIZE = SIGNONSTATE_MAX + 1;

const ::google::protobuf::EnumDescriptor* SIGNONSTATE_descriptor();
inline const ::std::string& SIGNONSTATE_Name(SIGNONSTATE value) {
  return ::google::protobuf::internal::NameOfEnum(
    SIGNONSTATE_descriptor(), value);
}
inline bool SIGNONSTATE_Parse(
    const ::std::string& name, SIGNONSTATE* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SIGNONSTATE>(
    SIGNONSTATE_descriptor(), name, value);
}
enum CLC_Messages {
  clc_ClientInfo = 8,
  clc_Move = 9,
  clc_VoiceData = 10,
  clc_BaselineAck = 11,
  clc_ListenEvents = 12,
  clc_RespondCvarValue = 13,
  clc_FileCRCCheck = 14,
  clc_LoadingProgress = 15,
  clc_SplitPlayerConnect = 16,
  clc_ClientMessage = 17
};
bool CLC_Messages_IsValid(int value);
const CLC_Messages CLC_Messages_MIN = clc_ClientInfo;
const CLC_Messages CLC_Messages_MAX = clc_ClientMessage;
const int CLC_Messages_ARRAYSIZE = CLC_Messages_MAX + 1;

const ::google::protobuf::EnumDescriptor* CLC_Messages_descriptor();
inline const ::std::string& CLC_Messages_Name(CLC_Messages value) {
  return ::google::protobuf::internal::NameOfEnum(
    CLC_Messages_descriptor(), value);
}
inline bool CLC_Messages_Parse(
    const ::std::string& name, CLC_Messages* value) {
  return ::google::protobuf::internal::ParseNamedEnum<CLC_Messages>(
    CLC_Messages_descriptor(), name, value);
}
enum VoiceDataFormat_t {
  VOICEDATA_FORMAT_STEAM = 0,
  VOICEDATA_FORMAT_ENGINE = 1
};
bool VoiceDataFormat_t_IsValid(int value);
const VoiceDataFormat_t VoiceDataFormat_t_MIN = VOICEDATA_FORMAT_STEAM;
const VoiceDataFormat_t VoiceDataFormat_t_MAX = VOICEDATA_FORMAT_ENGINE;
const int VoiceDataFormat_t_ARRAYSIZE = VoiceDataFormat_t_MAX + 1;

const ::google::protobuf::EnumDescriptor* VoiceDataFormat_t_descriptor();
inline const ::std::string& VoiceDataFormat_t_Name(VoiceDataFormat_t value) {
  return ::google::protobuf::internal::NameOfEnum(
    VoiceDataFormat_t_descriptor(), value);
}
inline bool VoiceDataFormat_t_Parse(
    const ::std::string& name, VoiceDataFormat_t* value) {
  return ::google::protobuf::internal::ParseNamedEnum<VoiceDataFormat_t>(
    VoiceDataFormat_t_descriptor(), name, value);
}
enum SVC_Messages {
  svc_ServerInfo = 8,
  svc_SendTable = 9,
  svc_ClassInfo = 10,
  svc_SetPause = 11,
  svc_CreateStringTable = 12,
  svc_UpdateStringTable = 13,
  svc_VoiceInit = 14,
  svc_VoiceData = 15,
  svc_Print = 16,
  svc_Sounds = 17,
  svc_SetView = 18,
  svc_FixAngle = 19,
  svc_CrosshairAngle = 20,
  svc_BSPDecal = 21,
  svc_SplitScreen = 22,
  svc_UserMessage = 23,
  svc_EntityMessage = 24,
  svc_GameEvent = 25,
  svc_PacketEntities = 26,
  svc_TempEntities = 27,
  svc_Prefetch = 28,
  svc_Menu = 29,
  svc_GameEventList = 30,
  svc_GetCvarValue = 31,
  svc_PacketReliable = 32
};
bool SVC_Messages_IsValid(int value);
const SVC_Messages SVC_Messages_MIN = svc_ServerInfo;
const SVC_Messages SVC_Messages_MAX = svc_PacketReliable;
const int SVC_Messages_ARRAYSIZE = SVC_Messages_MAX + 1;

const ::google::protobuf::EnumDescriptor* SVC_Messages_descriptor();
inline const ::std::string& SVC_Messages_Name(SVC_Messages value) {
  return ::google::protobuf::internal::NameOfEnum(
    SVC_Messages_descriptor(), value);
}
inline bool SVC_Messages_Parse(
    const ::std::string& name, SVC_Messages* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SVC_Messages>(
    SVC_Messages_descriptor(), name, value);
}
enum ESplitScreenMessageType {
  MSG_SPLITSCREEN_ADDUSER = 0,
  MSG_SPLITSCREEN_REMOVEUSER = 1
};
bool ESplitScreenMessageType_IsValid(int value);
const ESplitScreenMessageType ESplitScreenMessageType_MIN = MSG_SPLITSCREEN_ADDUSER;
const ESplitScreenMessageType ESplitScreenMessageType_MAX = MSG_SPLITSCREEN_REMOVEUSER;
const int ESplitScreenMessageType_ARRAYSIZE = ESplitScreenMessageType_MAX + 1;

const ::google::protobuf::EnumDescriptor* ESplitScreenMessageType_descriptor();
inline const ::std::string& ESplitScreenMessageType_Name(ESplitScreenMessageType value) {
  return ::google::protobuf::internal::NameOfEnum(
    ESplitScreenMessageType_descriptor(), value);
}
inline bool ESplitScreenMessageType_Parse(
    const ::std::string& name, ESplitScreenMessageType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ESplitScreenMessageType>(
    ESplitScreenMessageType_descriptor(), name, value);
}
// ===================================================================

class CMsgVector : public ::google::protobuf::Message {
 public:
  CMsgVector();
  virtual ~CMsgVector();
  
  CMsgVector(const CMsgVector& from);
  
  inline CMsgVector& operator=(const CMsgVector& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CMsgVector& default_instance();
  
  void Swap(CMsgVector* other);
  
  // implements Message ----------------------------------------------
  
  CMsgVector* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CMsgVector& from);
  void MergeFrom(const CMsgVector& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional float x = 1;
  inline bool has_x() const;
  inline void clear_x();
  static const int kXFieldNumber = 1;
  inline float x() const;
  inline void set_x(float value);
  
  // optional float y = 2;
  inline bool has_y() const;
  inline void clear_y();
  static const int kYFieldNumber = 2;
  inline float y() const;
  inline void set_y(float value);
  
  // optional float z = 3;
  inline bool has_z() const;
  inline void clear_z();
  static const int kZFieldNumber = 3;
  inline float z() const;
  inline void set_z(float value);
  
  // @@protoc_insertion_point(class_scope:CMsgVector)
 private:
  inline void set_has_x();
  inline void clear_has_x();
  inline void set_has_y();
  inline void clear_has_y();
  inline void set_has_z();
  inline void clear_has_z();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  float x_;
  float y_;
  float z_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CMsgVector* default_instance_;
};
// -------------------------------------------------------------------

class CMsgVector2D : public ::google::protobuf::Message {
 public:
  CMsgVector2D();
  virtual ~CMsgVector2D();
  
  CMsgVector2D(const CMsgVector2D& from);
  
  inline CMsgVector2D& operator=(const CMsgVector2D& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CMsgVector2D& default_instance();
  
  void Swap(CMsgVector2D* other);
  
  // implements Message ----------------------------------------------
  
  CMsgVector2D* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CMsgVector2D& from);
  void MergeFrom(const CMsgVector2D& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional float x = 1;
  inline bool has_x() const;
  inline void clear_x();
  static const int kXFieldNumber = 1;
  inline float x() const;
  inline void set_x(float value);
  
  // optional float y = 2;
  inline bool has_y() const;
  inline void clear_y();
  static const int kYFieldNumber = 2;
  inline float y() const;
  inline void set_y(float value);
  
  // @@protoc_insertion_point(class_scope:CMsgVector2D)
 private:
  inline void set_has_x();
  inline void clear_has_x();
  inline void set_has_y();
  inline void clear_has_y();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  float x_;
  float y_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CMsgVector2D* default_instance_;
};
// -------------------------------------------------------------------

class CMsgQAngle : public ::google::protobuf::Message {
 public:
  CMsgQAngle();
  virtual ~CMsgQAngle();
  
  CMsgQAngle(const CMsgQAngle& from);
  
  inline CMsgQAngle& operator=(const CMsgQAngle& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CMsgQAngle& default_instance();
  
  void Swap(CMsgQAngle* other);
  
  // implements Message ----------------------------------------------
  
  CMsgQAngle* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CMsgQAngle& from);
  void MergeFrom(const CMsgQAngle& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional float x = 1;
  inline bool has_x() const;
  inline void clear_x();
  static const int kXFieldNumber = 1;
  inline float x() const;
  inline void set_x(float value);
  
  // optional float y = 2;
  inline bool has_y() const;
  inline void clear_y();
  static const int kYFieldNumber = 2;
  inline float y() const;
  inline void set_y(float value);
  
  // optional float z = 3;
  inline bool has_z() const;
  inline void clear_z();
  static const int kZFieldNumber = 3;
  inline float z() const;
  inline void set_z(float value);
  
  // @@protoc_insertion_point(class_scope:CMsgQAngle)
 private:
  inline void set_has_x();
  inline void clear_has_x();
  inline void set_has_y();
  inline void clear_has_y();
  inline void set_has_z();
  inline void clear_has_z();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  float x_;
  float y_;
  float z_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CMsgQAngle* default_instance_;
};
// -------------------------------------------------------------------

class CMsg_CVars_CVar : public ::google::protobuf::Message {
 public:
  CMsg_CVars_CVar();
  virtual ~CMsg_CVars_CVar();
  
  CMsg_CVars_CVar(const CMsg_CVars_CVar& from);
  
  inline CMsg_CVars_CVar& operator=(const CMsg_CVars_CVar& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CMsg_CVars_CVar& default_instance();
  
  void Swap(CMsg_CVars_CVar* other);
  
  // implements Message ----------------------------------------------
  
  CMsg_CVars_CVar* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CMsg_CVars_CVar& from);
  void MergeFrom(const CMsg_CVars_CVar& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  
  // optional string value = 2;
  inline bool has_value() const;
  inline void clear_value();
  static const int kValueFieldNumber = 2;
  inline const ::std::string& value() const;
  inline void set_value(const ::std::string& value);
  inline void set_value(const char* value);
  inline void set_value(const char* value, size_t size);
  inline ::std::string* mutable_value();
  inline ::std::string* release_value();
  
  // @@protoc_insertion_point(class_scope:CMsg_CVars.CVar)
 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_value();
  inline void clear_has_value();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* name_;
  ::std::string* value_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CMsg_CVars_CVar* default_instance_;
};
// -------------------------------------------------------------------

class CMsg_CVars : public ::google::protobuf::Message {
 public:
  CMsg_CVars();
  virtual ~CMsg_CVars();
  
  CMsg_CVars(const CMsg_CVars& from);
  
  inline CMsg_CVars& operator=(const CMsg_CVars& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CMsg_CVars& default_instance();
  
  void Swap(CMsg_CVars* other);
  
  // implements Message ----------------------------------------------
  
  CMsg_CVars* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CMsg_CVars& from);
  void MergeFrom(const CMsg_CVars& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef CMsg_CVars_CVar CVar;
  
  // accessors -------------------------------------------------------
  
  // repeated .CMsg_CVars.CVar cvars = 1;
  inline int cvars_size() const;
  inline void clear_cvars();
  static const int kCvarsFieldNumber = 1;
  inline const ::CMsg_CVars_CVar& cvars(int index) const;
  inline ::CMsg_CVars_CVar* mutable_cvars(int index);
  inline ::CMsg_CVars_CVar* add_cvars();
  inline const ::google::protobuf::RepeatedPtrField< ::CMsg_CVars_CVar >&
      cvars() const;
  inline ::google::protobuf::RepeatedPtrField< ::CMsg_CVars_CVar >*
      mutable_cvars();
  
  // @@protoc_insertion_point(class_scope:CMsg_CVars)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::CMsg_CVars_CVar > cvars_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CMsg_CVars* default_instance_;
};
// -------------------------------------------------------------------

class CNETMsg_NOP : public ::google::protobuf::Message {
 public:
  CNETMsg_NOP();
  virtual ~CNETMsg_NOP();
  
  CNETMsg_NOP(const CNETMsg_NOP& from);
  
  inline CNETMsg_NOP& operator=(const CNETMsg_NOP& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CNETMsg_NOP& default_instance();
  
  void Swap(CNETMsg_NOP* other);
  
  // implements Message ----------------------------------------------
  
  CNETMsg_NOP* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CNETMsg_NOP& from);
  void MergeFrom(const CNETMsg_NOP& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // @@protoc_insertion_point(class_scope:CNETMsg_NOP)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CNETMsg_NOP* default_instance_;
};
// -------------------------------------------------------------------

class CNETMsg_Disconnect : public ::google::protobuf::Message {
 public:
  CNETMsg_Disconnect();
  virtual ~CNETMsg_Disconnect();
  
  CNETMsg_Disconnect(const CNETMsg_Disconnect& from);
  
  inline CNETMsg_Disconnect& operator=(const CNETMsg_Disconnect& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CNETMsg_Disconnect& default_instance();
  
  void Swap(CNETMsg_Disconnect* other);
  
  // implements Message ----------------------------------------------
  
  CNETMsg_Disconnect* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CNETMsg_Disconnect& from);
  void MergeFrom(const CNETMsg_Disconnect& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional string text = 1;
  inline bool has_text() const;
  inline void clear_text();
  static const int kTextFieldNumber = 1;
  inline const ::std::string& text() const;
  inline void set_text(const ::std::string& value);
  inline void set_text(const char* value);
  inline void set_text(const char* value, size_t size);
  inline ::std::string* mutable_text();
  inline ::std::string* release_text();
  
  // @@protoc_insertion_point(class_scope:CNETMsg_Disconnect)
 private:
  inline void set_has_text();
  inline void clear_has_text();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* text_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CNETMsg_Disconnect* default_instance_;
};
// -------------------------------------------------------------------

class CNETMsg_File : public ::google::protobuf::Message {
 public:
  CNETMsg_File();
  virtual ~CNETMsg_File();
  
  CNETMsg_File(const CNETMsg_File& from);
  
  inline CNETMsg_File& operator=(const CNETMsg_File& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CNETMsg_File& default_instance();
  
  void Swap(CNETMsg_File* other);
  
  // implements Message ----------------------------------------------
  
  CNETMsg_File* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CNETMsg_File& from);
  void MergeFrom(const CNETMsg_File& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 transfer_id = 1;
  inline bool has_transfer_id() const;
  inline void clear_transfer_id();
  static const int kTransferIdFieldNumber = 1;
  inline ::google::protobuf::int32 transfer_id() const;
  inline void set_transfer_id(::google::protobuf::int32 value);
  
  // optional string file_name = 2;
  inline bool has_file_name() const;
  inline void clear_file_name();
  static const int kFileNameFieldNumber = 2;
  inline const ::std::string& file_name() const;
  inline void set_file_name(const ::std::string& value);
  inline void set_file_name(const char* value);
  inline void set_file_name(const char* value, size_t size);
  inline ::std::string* mutable_file_name();
  inline ::std::string* release_file_name();
  
  // optional bool is_replay_demo_file = 3;
  inline bool has_is_replay_demo_file() const;
  inline void clear_is_replay_demo_file();
  static const int kIsReplayDemoFileFieldNumber = 3;
  inline bool is_replay_demo_file() const;
  inline void set_is_replay_demo_file(bool value);
  
  // optional bool deny = 4;
  inline bool has_deny() const;
  inline void clear_deny();
  static const int kDenyFieldNumber = 4;
  inline bool deny() const;
  inline void set_deny(bool value);
  
  // @@protoc_insertion_point(class_scope:CNETMsg_File)
 private:
  inline void set_has_transfer_id();
  inline void clear_has_transfer_id();
  inline void set_has_file_name();
  inline void clear_has_file_name();
  inline void set_has_is_replay_demo_file();
  inline void clear_has_is_replay_demo_file();
  inline void set_has_deny();
  inline void clear_has_deny();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* file_name_;
  ::google::protobuf::int32 transfer_id_;
  bool is_replay_demo_file_;
  bool deny_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CNETMsg_File* default_instance_;
};
// -------------------------------------------------------------------

class CNETMsg_SplitScreenUser : public ::google::protobuf::Message {
 public:
  CNETMsg_SplitScreenUser();
  virtual ~CNETMsg_SplitScreenUser();
  
  CNETMsg_SplitScreenUser(const CNETMsg_SplitScreenUser& from);
  
  inline CNETMsg_SplitScreenUser& operator=(const CNETMsg_SplitScreenUser& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CNETMsg_SplitScreenUser& default_instance();
  
  void Swap(CNETMsg_SplitScreenUser* other);
  
  // implements Message ----------------------------------------------
  
  CNETMsg_SplitScreenUser* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CNETMsg_SplitScreenUser& from);
  void MergeFrom(const CNETMsg_SplitScreenUser& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 slot = 1;
  inline bool has_slot() const;
  inline void clear_slot();
  static const int kSlotFieldNumber = 1;
  inline ::google::protobuf::int32 slot() const;
  inline void set_slot(::google::protobuf::int32 value);
  
  // @@protoc_insertion_point(class_scope:CNETMsg_SplitScreenUser)
 private:
  inline void set_has_slot();
  inline void clear_has_slot();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::int32 slot_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CNETMsg_SplitScreenUser* default_instance_;
};
// -------------------------------------------------------------------

class CNETMsg_Tick : public ::google::protobuf::Message {
 public:
  CNETMsg_Tick();
  virtual ~CNETMsg_Tick();
  
  CNETMsg_Tick(const CNETMsg_Tick& from);
  
  inline CNETMsg_Tick& operator=(const CNETMsg_Tick& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CNETMsg_Tick& default_instance();
  
  void Swap(CNETMsg_Tick* other);
  
  // implements Message ----------------------------------------------
  
  CNETMsg_Tick* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CNETMsg_Tick& from);
  void MergeFrom(const CNETMsg_Tick& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional uint32 tick = 1;
  inline bool has_tick() const;
  inline void clear_tick();
  static const int kTickFieldNumber = 1;
  inline ::google::protobuf::uint32 tick() const;
  inline void set_tick(::google::protobuf::uint32 value);
  
  // optional uint32 host_frametime = 2;
  inline bool has_host_frametime() const;
  inline void clear_host_frametime();
  static const int kHostFrametimeFieldNumber = 2;
  inline ::google::protobuf::uint32 host_frametime() const;
  inline void set_host_frametime(::google::protobuf::uint32 value);
  
  // optional uint32 host_frametime_std_deviation = 3;
  inline bool has_host_frametime_std_deviation() const;
  inline void clear_host_frametime_std_deviation();
  static const int kHostFrametimeStdDeviationFieldNumber = 3;
  inline ::google::protobuf::uint32 host_frametime_std_deviation() const;
  inline void set_host_frametime_std_deviation(::google::protobuf::uint32 value);
  
  // @@protoc_insertion_point(class_scope:CNETMsg_Tick)
 private:
  inline void set_has_tick();
  inline void clear_has_tick();
  inline void set_has_host_frametime();
  inline void clear_has_host_frametime();
  inline void set_has_host_frametime_std_deviation();
  inline void clear_has_host_frametime_std_deviation();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::uint32 tick_;
  ::google::protobuf::uint32 host_frametime_;
  ::google::protobuf::uint32 host_frametime_std_deviation_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CNETMsg_Tick* default_instance_;
};
// -------------------------------------------------------------------

class CNETMsg_StringCmd : public ::google::protobuf::Message {
 public:
  CNETMsg_StringCmd();
  virtual ~CNETMsg_StringCmd();
  
  CNETMsg_StringCmd(const CNETMsg_StringCmd& from);
  
  inline CNETMsg_StringCmd& operator=(const CNETMsg_StringCmd& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CNETMsg_StringCmd& default_instance();
  
  void Swap(CNETMsg_StringCmd* other);
  
  // implements Message ----------------------------------------------
  
  CNETMsg_StringCmd* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CNETMsg_StringCmd& from);
  void MergeFrom(const CNETMsg_StringCmd& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional string command = 1;
  inline bool has_command() const;
  inline void clear_command();
  static const int kCommandFieldNumber = 1;
  inline const ::std::string& command() const;
  inline void set_command(const ::std::string& value);
  inline void set_command(const char* value);
  inline void set_command(const char* value, size_t size);
  inline ::std::string* mutable_command();
  inline ::std::string* release_command();
  
  // @@protoc_insertion_point(class_scope:CNETMsg_StringCmd)
 private:
  inline void set_has_command();
  inline void clear_has_command();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* command_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CNETMsg_StringCmd* default_instance_;
};
// -------------------------------------------------------------------

class CNETMsg_SetConVar : public ::google::protobuf::Message {
 public:
  CNETMsg_SetConVar();
  virtual ~CNETMsg_SetConVar();
  
  CNETMsg_SetConVar(const CNETMsg_SetConVar& from);
  
  inline CNETMsg_SetConVar& operator=(const CNETMsg_SetConVar& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CNETMsg_SetConVar& default_instance();
  
  void Swap(CNETMsg_SetConVar* other);
  
  // implements Message ----------------------------------------------
  
  CNETMsg_SetConVar* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CNETMsg_SetConVar& from);
  void MergeFrom(const CNETMsg_SetConVar& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional .CMsg_CVars convars = 1;
  inline bool has_convars() const;
  inline void clear_convars();
  static const int kConvarsFieldNumber = 1;
  inline const ::CMsg_CVars& convars() const;
  inline ::CMsg_CVars* mutable_convars();
  inline ::CMsg_CVars* release_convars();
  
  // @@protoc_insertion_point(class_scope:CNETMsg_SetConVar)
 private:
  inline void set_has_convars();
  inline void clear_has_convars();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::CMsg_CVars* convars_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CNETMsg_SetConVar* default_instance_;
};
// -------------------------------------------------------------------

class CNETMsg_SignonState : public ::google::protobuf::Message {
 public:
  CNETMsg_SignonState();
  virtual ~CNETMsg_SignonState();
  
  CNETMsg_SignonState(const CNETMsg_SignonState& from);
  
  inline CNETMsg_SignonState& operator=(const CNETMsg_SignonState& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CNETMsg_SignonState& default_instance();
  
  void Swap(CNETMsg_SignonState* other);
  
  // implements Message ----------------------------------------------
  
  CNETMsg_SignonState* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CNETMsg_SignonState& from);
  void MergeFrom(const CNETMsg_SignonState& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional uint32 signon_state = 1;
  inline bool has_signon_state() const;
  inline void clear_signon_state();
  static const int kSignonStateFieldNumber = 1;
  inline ::google::protobuf::uint32 signon_state() const;
  inline void set_signon_state(::google::protobuf::uint32 value);
  
  // optional uint32 spawn_count = 2;
  inline bool has_spawn_count() const;
  inline void clear_spawn_count();
  static const int kSpawnCountFieldNumber = 2;
  inline ::google::protobuf::uint32 spawn_count() const;
  inline void set_spawn_count(::google::protobuf::uint32 value);
  
  // optional uint32 num_server_players = 3;
  inline bool has_num_server_players() const;
  inline void clear_num_server_players();
  static const int kNumServerPlayersFieldNumber = 3;
  inline ::google::protobuf::uint32 num_server_players() const;
  inline void set_num_server_players(::google::protobuf::uint32 value);
  
  // repeated string players_networkids = 4;
  inline int players_networkids_size() const;
  inline void clear_players_networkids();
  static const int kPlayersNetworkidsFieldNumber = 4;
  inline const ::std::string& players_networkids(int index) const;
  inline ::std::string* mutable_players_networkids(int index);
  inline void set_players_networkids(int index, const ::std::string& value);
  inline void set_players_networkids(int index, const char* value);
  inline void set_players_networkids(int index, const char* value, size_t size);
  inline ::std::string* add_players_networkids();
  inline void add_players_networkids(const ::std::string& value);
  inline void add_players_networkids(const char* value);
  inline void add_players_networkids(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& players_networkids() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_players_networkids();
  
  // optional string map_name = 5;
  inline bool has_map_name() const;
  inline void clear_map_name();
  static const int kMapNameFieldNumber = 5;
  inline const ::std::string& map_name() const;
  inline void set_map_name(const ::std::string& value);
  inline void set_map_name(const char* value);
  inline void set_map_name(const char* value, size_t size);
  inline ::std::string* mutable_map_name();
  inline ::std::string* release_map_name();
  
  // @@protoc_insertion_point(class_scope:CNETMsg_SignonState)
 private:
  inline void set_has_signon_state();
  inline void clear_has_signon_state();
  inline void set_has_spawn_count();
  inline void clear_has_spawn_count();
  inline void set_has_num_server_players();
  inline void clear_has_num_server_players();
  inline void set_has_map_name();
  inline void clear_has_map_name();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::uint32 signon_state_;
  ::google::protobuf::uint32 spawn_count_;
  ::google::protobuf::RepeatedPtrField< ::std::string> players_networkids_;
  ::std::string* map_name_;
  ::google::protobuf::uint32 num_server_players_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CNETMsg_SignonState* default_instance_;
};
// -------------------------------------------------------------------

class CCLCMsg_ClientInfo : public ::google::protobuf::Message {
 public:
  CCLCMsg_ClientInfo();
  virtual ~CCLCMsg_ClientInfo();
  
  CCLCMsg_ClientInfo(const CCLCMsg_ClientInfo& from);
  
  inline CCLCMsg_ClientInfo& operator=(const CCLCMsg_ClientInfo& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CCLCMsg_ClientInfo& default_instance();
  
  void Swap(CCLCMsg_ClientInfo* other);
  
  // implements Message ----------------------------------------------
  
  CCLCMsg_ClientInfo* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CCLCMsg_ClientInfo& from);
  void MergeFrom(const CCLCMsg_ClientInfo& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional fixed32 send_table_crc = 1;
  inline bool has_send_table_crc() const;
  inline void clear_send_table_crc();
  static const int kSendTableCrcFieldNumber = 1;
  inline ::google::protobuf::uint32 send_table_crc() const;
  inline void set_send_table_crc(::google::protobuf::uint32 value);
  
  // optional uint32 server_count = 2;
  inline bool has_server_count() const;
  inline void clear_server_count();
  static const int kServerCountFieldNumber = 2;
  inline ::google::protobuf::uint32 server_count() const;
  inline void set_server_count(::google::protobuf::uint32 value);
  
  // optional bool is_hltv = 3;
  inline bool has_is_hltv() const;
  inline void clear_is_hltv();
  static const int kIsHltvFieldNumber = 3;
  inline bool is_hltv() const;
  inline void set_is_hltv(bool value);
  
  // optional bool is_replay = 4;
  inline bool has_is_replay() const;
  inline void clear_is_replay();
  static const int kIsReplayFieldNumber = 4;
  inline bool is_replay() const;
  inline void set_is_replay(bool value);
  
  // optional uint32 friends_id = 5;
  inline bool has_friends_id() const;
  inline void clear_friends_id();
  static const int kFriendsIdFieldNumber = 5;
  inline ::google::protobuf::uint32 friends_id() const;
  inline void set_friends_id(::google::protobuf::uint32 value);
  
  // optional string friends_name = 6;
  inline bool has_friends_name() const;
  inline void clear_friends_name();
  static const int kFriendsNameFieldNumber = 6;
  inline const ::std::string& friends_name() const;
  inline void set_friends_name(const ::std::string& value);
  inline void set_friends_name(const char* value);
  inline void set_friends_name(const char* value, size_t size);
  inline ::std::string* mutable_friends_name();
  inline ::std::string* release_friends_name();
  
  // repeated fixed32 custom_files = 7;
  inline int custom_files_size() const;
  inline void clear_custom_files();
  static const int kCustomFilesFieldNumber = 7;
  inline ::google::protobuf::uint32 custom_files(int index) const;
  inline void set_custom_files(int index, ::google::protobuf::uint32 value);
  inline void add_custom_files(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      custom_files() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_custom_files();
  
  // @@protoc_insertion_point(class_scope:CCLCMsg_ClientInfo)
 private:
  inline void set_has_send_table_crc();
  inline void clear_has_send_table_crc();
  inline void set_has_server_count();
  inline void clear_has_server_count();
  inline void set_has_is_hltv();
  inline void clear_has_is_hltv();
  inline void set_has_is_replay();
  inline void clear_has_is_replay();
  inline void set_has_friends_id();
  inline void clear_has_friends_id();
  inline void set_has_friends_name();
  inline void clear_has_friends_name();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::uint32 send_table_crc_;
  ::google::protobuf::uint32 server_count_;
  bool is_hltv_;
  bool is_replay_;
  ::google::protobuf::uint32 friends_id_;
  ::std::string* friends_name_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > custom_files_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CCLCMsg_ClientInfo* default_instance_;
};
// -------------------------------------------------------------------

class CCLCMsg_Move : public ::google::protobuf::Message {
 public:
  CCLCMsg_Move();
  virtual ~CCLCMsg_Move();
  
  CCLCMsg_Move(const CCLCMsg_Move& from);
  
  inline CCLCMsg_Move& operator=(const CCLCMsg_Move& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CCLCMsg_Move& default_instance();
  
  void Swap(CCLCMsg_Move* other);
  
  // implements Message ----------------------------------------------
  
  CCLCMsg_Move* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CCLCMsg_Move& from);
  void MergeFrom(const CCLCMsg_Move& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional uint32 num_backup_commands = 1;
  inline bool has_num_backup_commands() const;
  inline void clear_num_backup_commands();
  static const int kNumBackupCommandsFieldNumber = 1;
  inline ::google::protobuf::uint32 num_backup_commands() const;
  inline void set_num_backup_commands(::google::protobuf::uint32 value);
  
  // optional uint32 num_new_commands = 2;
  inline bool has_num_new_commands() const;
  inline void clear_num_new_commands();
  static const int kNumNewCommandsFieldNumber = 2;
  inline ::google::protobuf::uint32 num_new_commands() const;
  inline void set_num_new_commands(::google::protobuf::uint32 value);
  
  // optional bytes data = 3;
  inline bool has_data() const;
  inline void clear_data();
  static const int kDataFieldNumber = 3;
  inline const ::std::string& data() const;
  inline void set_data(const ::std::string& value);
  inline void set_data(const char* value);
  inline void set_data(const void* value, size_t size);
  inline ::std::string* mutable_data();
  inline ::std::string* release_data();
  
  // @@protoc_insertion_point(class_scope:CCLCMsg_Move)
 private:
  inline void set_has_num_backup_commands();
  inline void clear_has_num_backup_commands();
  inline void set_has_num_new_commands();
  inline void clear_has_num_new_commands();
  inline void set_has_data();
  inline void clear_has_data();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::uint32 num_backup_commands_;
  ::google::protobuf::uint32 num_new_commands_;
  ::std::string* data_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CCLCMsg_Move* default_instance_;
};
// -------------------------------------------------------------------

class CCLCMsg_VoiceData : public ::google::protobuf::Message {
 public:
  CCLCMsg_VoiceData();
  virtual ~CCLCMsg_VoiceData();
  
  CCLCMsg_VoiceData(const CCLCMsg_VoiceData& from);
  
  inline CCLCMsg_VoiceData& operator=(const CCLCMsg_VoiceData& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CCLCMsg_VoiceData& default_instance();
  
  void Swap(CCLCMsg_VoiceData* other);
  
  // implements Message ----------------------------------------------
  
  CCLCMsg_VoiceData* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CCLCMsg_VoiceData& from);
  void MergeFrom(const CCLCMsg_VoiceData& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional bytes data = 1;
  inline bool has_data() const;
  inline void clear_data();
  static const int kDataFieldNumber = 1;
  inline const ::std::string& data() const;
  inline void set_data(const ::std::string& value);
  inline void set_data(const char* value);
  inline void set_data(const void* value, size_t size);
  inline ::std::string* mutable_data();
  inline ::std::string* release_data();
  
  // optional fixed64 xuid = 2;
  inline bool has_xuid() const;
  inline void clear_xuid();
  static const int kXuidFieldNumber = 2;
  inline ::google::protobuf::uint64 xuid() const;
  inline void set_xuid(::google::protobuf::uint64 value);
  
  // optional .VoiceDataFormat_t format = 3 [default = VOICEDATA_FORMAT_STEAM];
  inline bool has_format() const;
  inline void clear_format();
  static const int kFormatFieldNumber = 3;
  inline VoiceDataFormat_t format() const;
  inline void set_format(VoiceDataFormat_t value);
  
  // @@protoc_insertion_point(class_scope:CCLCMsg_VoiceData)
 private:
  inline void set_has_data();
  inline void clear_has_data();
  inline void set_has_xuid();
  inline void clear_has_xuid();
  inline void set_has_format();
  inline void clear_has_format();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* data_;
  ::google::protobuf::uint64 xuid_;
  int format_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CCLCMsg_VoiceData* default_instance_;
};
// -------------------------------------------------------------------

class CCLCMsg_BaselineAck : public ::google::protobuf::Message {
 public:
  CCLCMsg_BaselineAck();
  virtual ~CCLCMsg_BaselineAck();
  
  CCLCMsg_BaselineAck(const CCLCMsg_BaselineAck& from);
  
  inline CCLCMsg_BaselineAck& operator=(const CCLCMsg_BaselineAck& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CCLCMsg_BaselineAck& default_instance();
  
  void Swap(CCLCMsg_BaselineAck* other);
  
  // implements Message ----------------------------------------------
  
  CCLCMsg_BaselineAck* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CCLCMsg_BaselineAck& from);
  void MergeFrom(const CCLCMsg_BaselineAck& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 baseline_tick = 1;
  inline bool has_baseline_tick() const;
  inline void clear_baseline_tick();
  static const int kBaselineTickFieldNumber = 1;
  inline ::google::protobuf::int32 baseline_tick() const;
  inline void set_baseline_tick(::google::protobuf::int32 value);
  
  // optional int32 baseline_nr = 2;
  inline bool has_baseline_nr() const;
  inline void clear_baseline_nr();
  static const int kBaselineNrFieldNumber = 2;
  inline ::google::protobuf::int32 baseline_nr() const;
  inline void set_baseline_nr(::google::protobuf::int32 value);
  
  // @@protoc_insertion_point(class_scope:CCLCMsg_BaselineAck)
 private:
  inline void set_has_baseline_tick();
  inline void clear_has_baseline_tick();
  inline void set_has_baseline_nr();
  inline void clear_has_baseline_nr();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::int32 baseline_tick_;
  ::google::protobuf::int32 baseline_nr_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CCLCMsg_BaselineAck* default_instance_;
};
// -------------------------------------------------------------------

class CCLCMsg_ListenEvents : public ::google::protobuf::Message {
 public:
  CCLCMsg_ListenEvents();
  virtual ~CCLCMsg_ListenEvents();
  
  CCLCMsg_ListenEvents(const CCLCMsg_ListenEvents& from);
  
  inline CCLCMsg_ListenEvents& operator=(const CCLCMsg_ListenEvents& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CCLCMsg_ListenEvents& default_instance();
  
  void Swap(CCLCMsg_ListenEvents* other);
  
  // implements Message ----------------------------------------------
  
  CCLCMsg_ListenEvents* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CCLCMsg_ListenEvents& from);
  void MergeFrom(const CCLCMsg_ListenEvents& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated fixed32 event_mask = 1;
  inline int event_mask_size() const;
  inline void clear_event_mask();
  static const int kEventMaskFieldNumber = 1;
  inline ::google::protobuf::uint32 event_mask(int index) const;
  inline void set_event_mask(int index, ::google::protobuf::uint32 value);
  inline void add_event_mask(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      event_mask() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_event_mask();
  
  // @@protoc_insertion_point(class_scope:CCLCMsg_ListenEvents)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > event_mask_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CCLCMsg_ListenEvents* default_instance_;
};
// -------------------------------------------------------------------

class CCLCMsg_RespondCvarValue : public ::google::protobuf::Message {
 public:
  CCLCMsg_RespondCvarValue();
  virtual ~CCLCMsg_RespondCvarValue();
  
  CCLCMsg_RespondCvarValue(const CCLCMsg_RespondCvarValue& from);
  
  inline CCLCMsg_RespondCvarValue& operator=(const CCLCMsg_RespondCvarValue& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CCLCMsg_RespondCvarValue& default_instance();
  
  void Swap(CCLCMsg_RespondCvarValue* other);
  
  // implements Message ----------------------------------------------
  
  CCLCMsg_RespondCvarValue* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CCLCMsg_RespondCvarValue& from);
  void MergeFrom(const CCLCMsg_RespondCvarValue& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 cookie = 1;
  inline bool has_cookie() const;
  inline void clear_cookie();
  static const int kCookieFieldNumber = 1;
  inline ::google::protobuf::int32 cookie() const;
  inline void set_cookie(::google::protobuf::int32 value);
  
  // optional int32 status_code = 2;
  inline bool has_status_code() const;
  inline void clear_status_code();
  static const int kStatusCodeFieldNumber = 2;
  inline ::google::protobuf::int32 status_code() const;
  inline void set_status_code(::google::protobuf::int32 value);
  
  // optional string name = 3;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 3;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  
  // optional string value = 4;
  inline bool has_value() const;
  inline void clear_value();
  static const int kValueFieldNumber = 4;
  inline const ::std::string& value() const;
  inline void set_value(const ::std::string& value);
  inline void set_value(const char* value);
  inline void set_value(const char* value, size_t size);
  inline ::std::string* mutable_value();
  inline ::std::string* release_value();
  
  // @@protoc_insertion_point(class_scope:CCLCMsg_RespondCvarValue)
 private:
  inline void set_has_cookie();
  inline void clear_has_cookie();
  inline void set_has_status_code();
  inline void clear_has_status_code();
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_value();
  inline void clear_has_value();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::int32 cookie_;
  ::google::protobuf::int32 status_code_;
  ::std::string* name_;
  ::std::string* value_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CCLCMsg_RespondCvarValue* default_instance_;
};
// -------------------------------------------------------------------

class CCLCMsg_FileCRCCheck : public ::google::protobuf::Message {
 public:
  CCLCMsg_FileCRCCheck();
  virtual ~CCLCMsg_FileCRCCheck();
  
  CCLCMsg_FileCRCCheck(const CCLCMsg_FileCRCCheck& from);
  
  inline CCLCMsg_FileCRCCheck& operator=(const CCLCMsg_FileCRCCheck& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CCLCMsg_FileCRCCheck& default_instance();
  
  void Swap(CCLCMsg_FileCRCCheck* other);
  
  // implements Message ----------------------------------------------
  
  CCLCMsg_FileCRCCheck* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CCLCMsg_FileCRCCheck& from);
  void MergeFrom(const CCLCMsg_FileCRCCheck& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 code_path = 1;
  inline bool has_code_path() const;
  inline void clear_code_path();
  static const int kCodePathFieldNumber = 1;
  inline ::google::protobuf::int32 code_path() const;
  inline void set_code_path(::google::protobuf::int32 value);
  
  // optional string path = 2;
  inline bool has_path() const;
  inline void clear_path();
  static const int kPathFieldNumber = 2;
  inline const ::std::string& path() const;
  inline void set_path(const ::std::string& value);
  inline void set_path(const char* value);
  inline void set_path(const char* value, size_t size);
  inline ::std::string* mutable_path();
  inline ::std::string* release_path();
  
  // optional int32 code_filename = 3;
  inline bool has_code_filename() const;
  inline void clear_code_filename();
  static const int kCodeFilenameFieldNumber = 3;
  inline ::google::protobuf::int32 code_filename() const;
  inline void set_code_filename(::google::protobuf::int32 value);
  
  // optional string filename = 4;
  inline bool has_filename() const;
  inline void clear_filename();
  static const int kFilenameFieldNumber = 4;
  inline const ::std::string& filename() const;
  inline void set_filename(const ::std::string& value);
  inline void set_filename(const char* value);
  inline void set_filename(const char* value, size_t size);
  inline ::std::string* mutable_filename();
  inline ::std::string* release_filename();
  
  // optional fixed32 crc = 5;
  inline bool has_crc() const;
  inline void clear_crc();
  static const int kCrcFieldNumber = 5;
  inline ::google::protobuf::uint32 crc() const;
  inline void set_crc(::google::protobuf::uint32 value);
  
  // @@protoc_insertion_point(class_scope:CCLCMsg_FileCRCCheck)
 private:
  inline void set_has_code_path();
  inline void clear_has_code_path();
  inline void set_has_path();
  inline void clear_has_path();
  inline void set_has_code_filename();
  inline void clear_has_code_filename();
  inline void set_has_filename();
  inline void clear_has_filename();
  inline void set_has_crc();
  inline void clear_has_crc();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* path_;
  ::google::protobuf::int32 code_path_;
  ::google::protobuf::int32 code_filename_;
  ::std::string* filename_;
  ::google::protobuf::uint32 crc_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CCLCMsg_FileCRCCheck* default_instance_;
};
// -------------------------------------------------------------------

class CCLCMsg_LoadingProgress : public ::google::protobuf::Message {
 public:
  CCLCMsg_LoadingProgress();
  virtual ~CCLCMsg_LoadingProgress();
  
  CCLCMsg_LoadingProgress(const CCLCMsg_LoadingProgress& from);
  
  inline CCLCMsg_LoadingProgress& operator=(const CCLCMsg_LoadingProgress& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CCLCMsg_LoadingProgress& default_instance();
  
  void Swap(CCLCMsg_LoadingProgress* other);
  
  // implements Message ----------------------------------------------
  
  CCLCMsg_LoadingProgress* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CCLCMsg_LoadingProgress& from);
  void MergeFrom(const CCLCMsg_LoadingProgress& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 progress = 1;
  inline bool has_progress() const;
  inline void clear_progress();
  static const int kProgressFieldNumber = 1;
  inline ::google::protobuf::int32 progress() const;
  inline void set_progress(::google::protobuf::int32 value);
  
  // @@protoc_insertion_point(class_scope:CCLCMsg_LoadingProgress)
 private:
  inline void set_has_progress();
  inline void clear_has_progress();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::int32 progress_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CCLCMsg_LoadingProgress* default_instance_;
};
// -------------------------------------------------------------------

class CCLCMsg_SplitPlayerConnect : public ::google::protobuf::Message {
 public:
  CCLCMsg_SplitPlayerConnect();
  virtual ~CCLCMsg_SplitPlayerConnect();
  
  CCLCMsg_SplitPlayerConnect(const CCLCMsg_SplitPlayerConnect& from);
  
  inline CCLCMsg_SplitPlayerConnect& operator=(const CCLCMsg_SplitPlayerConnect& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CCLCMsg_SplitPlayerConnect& default_instance();
  
  void Swap(CCLCMsg_SplitPlayerConnect* other);
  
  // implements Message ----------------------------------------------
  
  CCLCMsg_SplitPlayerConnect* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CCLCMsg_SplitPlayerConnect& from);
  void MergeFrom(const CCLCMsg_SplitPlayerConnect& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional .CMsg_CVars convars = 1;
  inline bool has_convars() const;
  inline void clear_convars();
  static const int kConvarsFieldNumber = 1;
  inline const ::CMsg_CVars& convars() const;
  inline ::CMsg_CVars* mutable_convars();
  inline ::CMsg_CVars* release_convars();
  
  // @@protoc_insertion_point(class_scope:CCLCMsg_SplitPlayerConnect)
 private:
  inline void set_has_convars();
  inline void clear_has_convars();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::CMsg_CVars* convars_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CCLCMsg_SplitPlayerConnect* default_instance_;
};
// -------------------------------------------------------------------

class CCLCMsg_ClientMessage : public ::google::protobuf::Message {
 public:
  CCLCMsg_ClientMessage();
  virtual ~CCLCMsg_ClientMessage();
  
  CCLCMsg_ClientMessage(const CCLCMsg_ClientMessage& from);
  
  inline CCLCMsg_ClientMessage& operator=(const CCLCMsg_ClientMessage& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CCLCMsg_ClientMessage& default_instance();
  
  void Swap(CCLCMsg_ClientMessage* other);
  
  // implements Message ----------------------------------------------
  
  CCLCMsg_ClientMessage* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CCLCMsg_ClientMessage& from);
  void MergeFrom(const CCLCMsg_ClientMessage& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 msg_type = 1;
  inline bool has_msg_type() const;
  inline void clear_msg_type();
  static const int kMsgTypeFieldNumber = 1;
  inline ::google::protobuf::int32 msg_type() const;
  inline void set_msg_type(::google::protobuf::int32 value);
  
  // optional bytes data = 2;
  inline bool has_data() const;
  inline void clear_data();
  static const int kDataFieldNumber = 2;
  inline const ::std::string& data() const;
  inline void set_data(const ::std::string& value);
  inline void set_data(const char* value);
  inline void set_data(const void* value, size_t size);
  inline ::std::string* mutable_data();
  inline ::std::string* release_data();
  
  // @@protoc_insertion_point(class_scope:CCLCMsg_ClientMessage)
 private:
  inline void set_has_msg_type();
  inline void clear_has_msg_type();
  inline void set_has_data();
  inline void clear_has_data();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* data_;
  ::google::protobuf::int32 msg_type_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CCLCMsg_ClientMessage* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_ServerInfo : public ::google::protobuf::Message {
 public:
  CSVCMsg_ServerInfo();
  virtual ~CSVCMsg_ServerInfo();
  
  CSVCMsg_ServerInfo(const CSVCMsg_ServerInfo& from);
  
  inline CSVCMsg_ServerInfo& operator=(const CSVCMsg_ServerInfo& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_ServerInfo& default_instance();
  
  void Swap(CSVCMsg_ServerInfo* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_ServerInfo* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_ServerInfo& from);
  void MergeFrom(const CSVCMsg_ServerInfo& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 protocol = 1;
  inline bool has_protocol() const;
  inline void clear_protocol();
  static const int kProtocolFieldNumber = 1;
  inline ::google::protobuf::int32 protocol() const;
  inline void set_protocol(::google::protobuf::int32 value);
  
  // optional int32 server_count = 2;
  inline bool has_server_count() const;
  inline void clear_server_count();
  static const int kServerCountFieldNumber = 2;
  inline ::google::protobuf::int32 server_count() const;
  inline void set_server_count(::google::protobuf::int32 value);
  
  // optional bool is_dedicated = 3;
  inline bool has_is_dedicated() const;
  inline void clear_is_dedicated();
  static const int kIsDedicatedFieldNumber = 3;
  inline bool is_dedicated() const;
  inline void set_is_dedicated(bool value);
  
  // optional bool is_hltv = 4;
  inline bool has_is_hltv() const;
  inline void clear_is_hltv();
  static const int kIsHltvFieldNumber = 4;
  inline bool is_hltv() const;
  inline void set_is_hltv(bool value);
  
  // optional bool is_replay = 5;
  inline bool has_is_replay() const;
  inline void clear_is_replay();
  static const int kIsReplayFieldNumber = 5;
  inline bool is_replay() const;
  inline void set_is_replay(bool value);
  
  // optional int32 c_os = 6;
  inline bool has_c_os() const;
  inline void clear_c_os();
  static const int kCOsFieldNumber = 6;
  inline ::google::protobuf::int32 c_os() const;
  inline void set_c_os(::google::protobuf::int32 value);
  
  // optional fixed32 map_crc = 7;
  inline bool has_map_crc() const;
  inline void clear_map_crc();
  static const int kMapCrcFieldNumber = 7;
  inline ::google::protobuf::uint32 map_crc() const;
  inline void set_map_crc(::google::protobuf::uint32 value);
  
  // optional fixed32 client_crc = 8;
  inline bool has_client_crc() const;
  inline void clear_client_crc();
  static const int kClientCrcFieldNumber = 8;
  inline ::google::protobuf::uint32 client_crc() const;
  inline void set_client_crc(::google::protobuf::uint32 value);
  
  // optional fixed32 string_table_crc = 9;
  inline bool has_string_table_crc() const;
  inline void clear_string_table_crc();
  static const int kStringTableCrcFieldNumber = 9;
  inline ::google::protobuf::uint32 string_table_crc() const;
  inline void set_string_table_crc(::google::protobuf::uint32 value);
  
  // optional int32 max_clients = 10;
  inline bool has_max_clients() const;
  inline void clear_max_clients();
  static const int kMaxClientsFieldNumber = 10;
  inline ::google::protobuf::int32 max_clients() const;
  inline void set_max_clients(::google::protobuf::int32 value);
  
  // optional int32 max_classes = 11;
  inline bool has_max_classes() const;
  inline void clear_max_classes();
  static const int kMaxClassesFieldNumber = 11;
  inline ::google::protobuf::int32 max_classes() const;
  inline void set_max_classes(::google::protobuf::int32 value);
  
  // optional int32 player_slot = 12;
  inline bool has_player_slot() const;
  inline void clear_player_slot();
  static const int kPlayerSlotFieldNumber = 12;
  inline ::google::protobuf::int32 player_slot() const;
  inline void set_player_slot(::google::protobuf::int32 value);
  
  // optional float tick_interval = 13;
  inline bool has_tick_interval() const;
  inline void clear_tick_interval();
  static const int kTickIntervalFieldNumber = 13;
  inline float tick_interval() const;
  inline void set_tick_interval(float value);
  
  // optional string game_dir = 14;
  inline bool has_game_dir() const;
  inline void clear_game_dir();
  static const int kGameDirFieldNumber = 14;
  inline const ::std::string& game_dir() const;
  inline void set_game_dir(const ::std::string& value);
  inline void set_game_dir(const char* value);
  inline void set_game_dir(const char* value, size_t size);
  inline ::std::string* mutable_game_dir();
  inline ::std::string* release_game_dir();
  
  // optional string map_name = 15;
  inline bool has_map_name() const;
  inline void clear_map_name();
  static const int kMapNameFieldNumber = 15;
  inline const ::std::string& map_name() const;
  inline void set_map_name(const ::std::string& value);
  inline void set_map_name(const char* value);
  inline void set_map_name(const char* value, size_t size);
  inline ::std::string* mutable_map_name();
  inline ::std::string* release_map_name();
  
  // optional string sky_name = 16;
  inline bool has_sky_name() const;
  inline void clear_sky_name();
  static const int kSkyNameFieldNumber = 16;
  inline const ::std::string& sky_name() const;
  inline void set_sky_name(const ::std::string& value);
  inline void set_sky_name(const char* value);
  inline void set_sky_name(const char* value, size_t size);
  inline ::std::string* mutable_sky_name();
  inline ::std::string* release_sky_name();
  
  // optional string host_name = 17;
  inline bool has_host_name() const;
  inline void clear_host_name();
  static const int kHostNameFieldNumber = 17;
  inline const ::std::string& host_name() const;
  inline void set_host_name(const ::std::string& value);
  inline void set_host_name(const char* value);
  inline void set_host_name(const char* value, size_t size);
  inline ::std::string* mutable_host_name();
  inline ::std::string* release_host_name();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_ServerInfo)
 private:
  inline void set_has_protocol();
  inline void clear_has_protocol();
  inline void set_has_server_count();
  inline void clear_has_server_count();
  inline void set_has_is_dedicated();
  inline void clear_has_is_dedicated();
  inline void set_has_is_hltv();
  inline void clear_has_is_hltv();
  inline void set_has_is_replay();
  inline void clear_has_is_replay();
  inline void set_has_c_os();
  inline void clear_has_c_os();
  inline void set_has_map_crc();
  inline void clear_has_map_crc();
  inline void set_has_client_crc();
  inline void clear_has_client_crc();
  inline void set_has_string_table_crc();
  inline void clear_has_string_table_crc();
  inline void set_has_max_clients();
  inline void clear_has_max_clients();
  inline void set_has_max_classes();
  inline void clear_has_max_classes();
  inline void set_has_player_slot();
  inline void clear_has_player_slot();
  inline void set_has_tick_interval();
  inline void clear_has_tick_interval();
  inline void set_has_game_dir();
  inline void clear_has_game_dir();
  inline void set_has_map_name();
  inline void clear_has_map_name();
  inline void set_has_sky_name();
  inline void clear_has_sky_name();
  inline void set_has_host_name();
  inline void clear_has_host_name();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::int32 protocol_;
  ::google::protobuf::int32 server_count_;
  bool is_dedicated_;
  bool is_hltv_;
  bool is_replay_;
  ::google::protobuf::int32 c_os_;
  ::google::protobuf::uint32 map_crc_;
  ::google::protobuf::uint32 client_crc_;
  ::google::protobuf::uint32 string_table_crc_;
  ::google::protobuf::int32 max_clients_;
  ::google::protobuf::int32 max_classes_;
  ::google::protobuf::int32 player_slot_;
  ::std::string* game_dir_;
  ::std::string* map_name_;
  ::std::string* sky_name_;
  ::std::string* host_name_;
  float tick_interval_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(17 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_ServerInfo* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_ClassInfo_class_t : public ::google::protobuf::Message {
 public:
  CSVCMsg_ClassInfo_class_t();
  virtual ~CSVCMsg_ClassInfo_class_t();
  
  CSVCMsg_ClassInfo_class_t(const CSVCMsg_ClassInfo_class_t& from);
  
  inline CSVCMsg_ClassInfo_class_t& operator=(const CSVCMsg_ClassInfo_class_t& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_ClassInfo_class_t& default_instance();
  
  void Swap(CSVCMsg_ClassInfo_class_t* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_ClassInfo_class_t* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_ClassInfo_class_t& from);
  void MergeFrom(const CSVCMsg_ClassInfo_class_t& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 class_id = 1;
  inline bool has_class_id() const;
  inline void clear_class_id();
  static const int kClassIdFieldNumber = 1;
  inline ::google::protobuf::int32 class_id() const;
  inline void set_class_id(::google::protobuf::int32 value);
  
  // optional string data_table_name = 2;
  inline bool has_data_table_name() const;
  inline void clear_data_table_name();
  static const int kDataTableNameFieldNumber = 2;
  inline const ::std::string& data_table_name() const;
  inline void set_data_table_name(const ::std::string& value);
  inline void set_data_table_name(const char* value);
  inline void set_data_table_name(const char* value, size_t size);
  inline ::std::string* mutable_data_table_name();
  inline ::std::string* release_data_table_name();
  
  // optional string class_name = 3;
  inline bool has_class_name() const;
  inline void clear_class_name();
  static const int kClassNameFieldNumber = 3;
  inline const ::std::string& class_name() const;
  inline void set_class_name(const ::std::string& value);
  inline void set_class_name(const char* value);
  inline void set_class_name(const char* value, size_t size);
  inline ::std::string* mutable_class_name();
  inline ::std::string* release_class_name();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_ClassInfo.class_t)
 private:
  inline void set_has_class_id();
  inline void clear_has_class_id();
  inline void set_has_data_table_name();
  inline void clear_has_data_table_name();
  inline void set_has_class_name();
  inline void clear_has_class_name();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* data_table_name_;
  ::std::string* class_name_;
  ::google::protobuf::int32 class_id_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_ClassInfo_class_t* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_ClassInfo : public ::google::protobuf::Message {
 public:
  CSVCMsg_ClassInfo();
  virtual ~CSVCMsg_ClassInfo();
  
  CSVCMsg_ClassInfo(const CSVCMsg_ClassInfo& from);
  
  inline CSVCMsg_ClassInfo& operator=(const CSVCMsg_ClassInfo& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_ClassInfo& default_instance();
  
  void Swap(CSVCMsg_ClassInfo* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_ClassInfo* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_ClassInfo& from);
  void MergeFrom(const CSVCMsg_ClassInfo& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef CSVCMsg_ClassInfo_class_t class_t;
  
  // accessors -------------------------------------------------------
  
  // optional bool create_on_client = 1;
  inline bool has_create_on_client() const;
  inline void clear_create_on_client();
  static const int kCreateOnClientFieldNumber = 1;
  inline bool create_on_client() const;
  inline void set_create_on_client(bool value);
  
  // repeated .CSVCMsg_ClassInfo.class_t classes = 2;
  inline int classes_size() const;
  inline void clear_classes();
  static const int kClassesFieldNumber = 2;
  inline const ::CSVCMsg_ClassInfo_class_t& classes(int index) const;
  inline ::CSVCMsg_ClassInfo_class_t* mutable_classes(int index);
  inline ::CSVCMsg_ClassInfo_class_t* add_classes();
  inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsg_ClassInfo_class_t >&
      classes() const;
  inline ::google::protobuf::RepeatedPtrField< ::CSVCMsg_ClassInfo_class_t >*
      mutable_classes();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_ClassInfo)
 private:
  inline void set_has_create_on_client();
  inline void clear_has_create_on_client();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::CSVCMsg_ClassInfo_class_t > classes_;
  bool create_on_client_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_ClassInfo* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_SetPause : public ::google::protobuf::Message {
 public:
  CSVCMsg_SetPause();
  virtual ~CSVCMsg_SetPause();
  
  CSVCMsg_SetPause(const CSVCMsg_SetPause& from);
  
  inline CSVCMsg_SetPause& operator=(const CSVCMsg_SetPause& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_SetPause& default_instance();
  
  void Swap(CSVCMsg_SetPause* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_SetPause* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_SetPause& from);
  void MergeFrom(const CSVCMsg_SetPause& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional bool paused = 1;
  inline bool has_paused() const;
  inline void clear_paused();
  static const int kPausedFieldNumber = 1;
  inline bool paused() const;
  inline void set_paused(bool value);
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_SetPause)
 private:
  inline void set_has_paused();
  inline void clear_has_paused();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  bool paused_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_SetPause* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_VoiceInit : public ::google::protobuf::Message {
 public:
  CSVCMsg_VoiceInit();
  virtual ~CSVCMsg_VoiceInit();
  
  CSVCMsg_VoiceInit(const CSVCMsg_VoiceInit& from);
  
  inline CSVCMsg_VoiceInit& operator=(const CSVCMsg_VoiceInit& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_VoiceInit& default_instance();
  
  void Swap(CSVCMsg_VoiceInit* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_VoiceInit* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_VoiceInit& from);
  void MergeFrom(const CSVCMsg_VoiceInit& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 quality = 1;
  inline bool has_quality() const;
  inline void clear_quality();
  static const int kQualityFieldNumber = 1;
  inline ::google::protobuf::int32 quality() const;
  inline void set_quality(::google::protobuf::int32 value);
  
  // optional string codec = 2;
  inline bool has_codec() const;
  inline void clear_codec();
  static const int kCodecFieldNumber = 2;
  inline const ::std::string& codec() const;
  inline void set_codec(const ::std::string& value);
  inline void set_codec(const char* value);
  inline void set_codec(const char* value, size_t size);
  inline ::std::string* mutable_codec();
  inline ::std::string* release_codec();
  
  // optional int32 version = 3 [default = 0];
  inline bool has_version() const;
  inline void clear_version();
  static const int kVersionFieldNumber = 3;
  inline ::google::protobuf::int32 version() const;
  inline void set_version(::google::protobuf::int32 value);
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_VoiceInit)
 private:
  inline void set_has_quality();
  inline void clear_has_quality();
  inline void set_has_codec();
  inline void clear_has_codec();
  inline void set_has_version();
  inline void clear_has_version();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* codec_;
  ::google::protobuf::int32 quality_;
  ::google::protobuf::int32 version_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_VoiceInit* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_Print : public ::google::protobuf::Message {
 public:
  CSVCMsg_Print();
  virtual ~CSVCMsg_Print();
  
  CSVCMsg_Print(const CSVCMsg_Print& from);
  
  inline CSVCMsg_Print& operator=(const CSVCMsg_Print& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_Print& default_instance();
  
  void Swap(CSVCMsg_Print* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_Print* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_Print& from);
  void MergeFrom(const CSVCMsg_Print& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional string text = 1;
  inline bool has_text() const;
  inline void clear_text();
  static const int kTextFieldNumber = 1;
  inline const ::std::string& text() const;
  inline void set_text(const ::std::string& value);
  inline void set_text(const char* value);
  inline void set_text(const char* value, size_t size);
  inline ::std::string* mutable_text();
  inline ::std::string* release_text();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_Print)
 private:
  inline void set_has_text();
  inline void clear_has_text();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* text_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_Print* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_Sounds_sounddata_t : public ::google::protobuf::Message {
 public:
  CSVCMsg_Sounds_sounddata_t();
  virtual ~CSVCMsg_Sounds_sounddata_t();
  
  CSVCMsg_Sounds_sounddata_t(const CSVCMsg_Sounds_sounddata_t& from);
  
  inline CSVCMsg_Sounds_sounddata_t& operator=(const CSVCMsg_Sounds_sounddata_t& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_Sounds_sounddata_t& default_instance();
  
  void Swap(CSVCMsg_Sounds_sounddata_t* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_Sounds_sounddata_t* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_Sounds_sounddata_t& from);
  void MergeFrom(const CSVCMsg_Sounds_sounddata_t& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional sint32 origin_x = 1;
  inline bool has_origin_x() const;
  inline void clear_origin_x();
  static const int kOriginXFieldNumber = 1;
  inline ::google::protobuf::int32 origin_x() const;
  inline void set_origin_x(::google::protobuf::int32 value);
  
  // optional sint32 origin_y = 2;
  inline bool has_origin_y() const;
  inline void clear_origin_y();
  static const int kOriginYFieldNumber = 2;
  inline ::google::protobuf::int32 origin_y() const;
  inline void set_origin_y(::google::protobuf::int32 value);
  
  // optional sint32 origin_z = 3;
  inline bool has_origin_z() const;
  inline void clear_origin_z();
  static const int kOriginZFieldNumber = 3;
  inline ::google::protobuf::int32 origin_z() const;
  inline void set_origin_z(::google::protobuf::int32 value);
  
  // optional uint32 volume = 4;
  inline bool has_volume() const;
  inline void clear_volume();
  static const int kVolumeFieldNumber = 4;
  inline ::google::protobuf::uint32 volume() const;
  inline void set_volume(::google::protobuf::uint32 value);
  
  // optional float delay_value = 5;
  inline bool has_delay_value() const;
  inline void clear_delay_value();
  static const int kDelayValueFieldNumber = 5;
  inline float delay_value() const;
  inline void set_delay_value(float value);
  
  // optional int32 sequence_number = 6;
  inline bool has_sequence_number() const;
  inline void clear_sequence_number();
  static const int kSequenceNumberFieldNumber = 6;
  inline ::google::protobuf::int32 sequence_number() const;
  inline void set_sequence_number(::google::protobuf::int32 value);
  
  // optional int32 entity_index = 7;
  inline bool has_entity_index() const;
  inline void clear_entity_index();
  static const int kEntityIndexFieldNumber = 7;
  inline ::google::protobuf::int32 entity_index() const;
  inline void set_entity_index(::google::protobuf::int32 value);
  
  // optional int32 channel = 8;
  inline bool has_channel() const;
  inline void clear_channel();
  static const int kChannelFieldNumber = 8;
  inline ::google::protobuf::int32 channel() const;
  inline void set_channel(::google::protobuf::int32 value);
  
  // optional int32 pitch = 9;
  inline bool has_pitch() const;
  inline void clear_pitch();
  static const int kPitchFieldNumber = 9;
  inline ::google::protobuf::int32 pitch() const;
  inline void set_pitch(::google::protobuf::int32 value);
  
  // optional int32 flags = 10;
  inline bool has_flags() const;
  inline void clear_flags();
  static const int kFlagsFieldNumber = 10;
  inline ::google::protobuf::int32 flags() const;
  inline void set_flags(::google::protobuf::int32 value);
  
  // optional uint32 sound_num = 11;
  inline bool has_sound_num() const;
  inline void clear_sound_num();
  static const int kSoundNumFieldNumber = 11;
  inline ::google::protobuf::uint32 sound_num() const;
  inline void set_sound_num(::google::protobuf::uint32 value);
  
  // optional fixed32 sound_num_handle = 12;
  inline bool has_sound_num_handle() const;
  inline void clear_sound_num_handle();
  static const int kSoundNumHandleFieldNumber = 12;
  inline ::google::protobuf::uint32 sound_num_handle() const;
  inline void set_sound_num_handle(::google::protobuf::uint32 value);
  
  // optional int32 speaker_entity = 13;
  inline bool has_speaker_entity() const;
  inline void clear_speaker_entity();
  static const int kSpeakerEntityFieldNumber = 13;
  inline ::google::protobuf::int32 speaker_entity() const;
  inline void set_speaker_entity(::google::protobuf::int32 value);
  
  // optional int32 random_seed = 14;
  inline bool has_random_seed() const;
  inline void clear_random_seed();
  static const int kRandomSeedFieldNumber = 14;
  inline ::google::protobuf::int32 random_seed() const;
  inline void set_random_seed(::google::protobuf::int32 value);
  
  // optional int32 sound_level = 15;
  inline bool has_sound_level() const;
  inline void clear_sound_level();
  static const int kSoundLevelFieldNumber = 15;
  inline ::google::protobuf::int32 sound_level() const;
  inline void set_sound_level(::google::protobuf::int32 value);
  
  // optional bool is_sentence = 16;
  inline bool has_is_sentence() const;
  inline void clear_is_sentence();
  static const int kIsSentenceFieldNumber = 16;
  inline bool is_sentence() const;
  inline void set_is_sentence(bool value);
  
  // optional bool is_ambient = 17;
  inline bool has_is_ambient() const;
  inline void clear_is_ambient();
  static const int kIsAmbientFieldNumber = 17;
  inline bool is_ambient() const;
  inline void set_is_ambient(bool value);
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_Sounds.sounddata_t)
 private:
  inline void set_has_origin_x();
  inline void clear_has_origin_x();
  inline void set_has_origin_y();
  inline void clear_has_origin_y();
  inline void set_has_origin_z();
  inline void clear_has_origin_z();
  inline void set_has_volume();
  inline void clear_has_volume();
  inline void set_has_delay_value();
  inline void clear_has_delay_value();
  inline void set_has_sequence_number();
  inline void clear_has_sequence_number();
  inline void set_has_entity_index();
  inline void clear_has_entity_index();
  inline void set_has_channel();
  inline void clear_has_channel();
  inline void set_has_pitch();
  inline void clear_has_pitch();
  inline void set_has_flags();
  inline void clear_has_flags();
  inline void set_has_sound_num();
  inline void clear_has_sound_num();
  inline void set_has_sound_num_handle();
  inline void clear_has_sound_num_handle();
  inline void set_has_speaker_entity();
  inline void clear_has_speaker_entity();
  inline void set_has_random_seed();
  inline void clear_has_random_seed();
  inline void set_has_sound_level();
  inline void clear_has_sound_level();
  inline void set_has_is_sentence();
  inline void clear_has_is_sentence();
  inline void set_has_is_ambient();
  inline void clear_has_is_ambient();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::int32 origin_x_;
  ::google::protobuf::int32 origin_y_;
  ::google::protobuf::int32 origin_z_;
  ::google::protobuf::uint32 volume_;
  float delay_value_;
  ::google::protobuf::int32 sequence_number_;
  ::google::protobuf::int32 entity_index_;
  ::google::protobuf::int32 channel_;
  ::google::protobuf::int32 pitch_;
  ::google::protobuf::int32 flags_;
  ::google::protobuf::uint32 sound_num_;
  ::google::protobuf::uint32 sound_num_handle_;
  ::google::protobuf::int32 speaker_entity_;
  ::google::protobuf::int32 random_seed_;
  ::google::protobuf::int32 sound_level_;
  bool is_sentence_;
  bool is_ambient_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(17 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_Sounds_sounddata_t* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_Sounds : public ::google::protobuf::Message {
 public:
  CSVCMsg_Sounds();
  virtual ~CSVCMsg_Sounds();
  
  CSVCMsg_Sounds(const CSVCMsg_Sounds& from);
  
  inline CSVCMsg_Sounds& operator=(const CSVCMsg_Sounds& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_Sounds& default_instance();
  
  void Swap(CSVCMsg_Sounds* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_Sounds* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_Sounds& from);
  void MergeFrom(const CSVCMsg_Sounds& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef CSVCMsg_Sounds_sounddata_t sounddata_t;
  
  // accessors -------------------------------------------------------
  
  // optional bool reliable_sound = 1;
  inline bool has_reliable_sound() const;
  inline void clear_reliable_sound();
  static const int kReliableSoundFieldNumber = 1;
  inline bool reliable_sound() const;
  inline void set_reliable_sound(bool value);
  
  // repeated .CSVCMsg_Sounds.sounddata_t sounds = 2;
  inline int sounds_size() const;
  inline void clear_sounds();
  static const int kSoundsFieldNumber = 2;
  inline const ::CSVCMsg_Sounds_sounddata_t& sounds(int index) const;
  inline ::CSVCMsg_Sounds_sounddata_t* mutable_sounds(int index);
  inline ::CSVCMsg_Sounds_sounddata_t* add_sounds();
  inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsg_Sounds_sounddata_t >&
      sounds() const;
  inline ::google::protobuf::RepeatedPtrField< ::CSVCMsg_Sounds_sounddata_t >*
      mutable_sounds();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_Sounds)
 private:
  inline void set_has_reliable_sound();
  inline void clear_has_reliable_sound();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::CSVCMsg_Sounds_sounddata_t > sounds_;
  bool reliable_sound_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_Sounds* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_Prefetch : public ::google::protobuf::Message {
 public:
  CSVCMsg_Prefetch();
  virtual ~CSVCMsg_Prefetch();
  
  CSVCMsg_Prefetch(const CSVCMsg_Prefetch& from);
  
  inline CSVCMsg_Prefetch& operator=(const CSVCMsg_Prefetch& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_Prefetch& default_instance();
  
  void Swap(CSVCMsg_Prefetch* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_Prefetch* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_Prefetch& from);
  void MergeFrom(const CSVCMsg_Prefetch& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 sound_index = 1;
  inline bool has_sound_index() const;
  inline void clear_sound_index();
  static const int kSoundIndexFieldNumber = 1;
  inline ::google::protobuf::int32 sound_index() const;
  inline void set_sound_index(::google::protobuf::int32 value);
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_Prefetch)
 private:
  inline void set_has_sound_index();
  inline void clear_has_sound_index();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::int32 sound_index_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_Prefetch* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_SetView : public ::google::protobuf::Message {
 public:
  CSVCMsg_SetView();
  virtual ~CSVCMsg_SetView();
  
  CSVCMsg_SetView(const CSVCMsg_SetView& from);
  
  inline CSVCMsg_SetView& operator=(const CSVCMsg_SetView& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_SetView& default_instance();
  
  void Swap(CSVCMsg_SetView* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_SetView* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_SetView& from);
  void MergeFrom(const CSVCMsg_SetView& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 entity_index = 1;
  inline bool has_entity_index() const;
  inline void clear_entity_index();
  static const int kEntityIndexFieldNumber = 1;
  inline ::google::protobuf::int32 entity_index() const;
  inline void set_entity_index(::google::protobuf::int32 value);
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_SetView)
 private:
  inline void set_has_entity_index();
  inline void clear_has_entity_index();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::int32 entity_index_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_SetView* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_FixAngle : public ::google::protobuf::Message {
 public:
  CSVCMsg_FixAngle();
  virtual ~CSVCMsg_FixAngle();
  
  CSVCMsg_FixAngle(const CSVCMsg_FixAngle& from);
  
  inline CSVCMsg_FixAngle& operator=(const CSVCMsg_FixAngle& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_FixAngle& default_instance();
  
  void Swap(CSVCMsg_FixAngle* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_FixAngle* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_FixAngle& from);
  void MergeFrom(const CSVCMsg_FixAngle& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional bool relative = 1;
  inline bool has_relative() const;
  inline void clear_relative();
  static const int kRelativeFieldNumber = 1;
  inline bool relative() const;
  inline void set_relative(bool value);
  
  // optional .CMsgQAngle angle = 2;
  inline bool has_angle() const;
  inline void clear_angle();
  static const int kAngleFieldNumber = 2;
  inline const ::CMsgQAngle& angle() const;
  inline ::CMsgQAngle* mutable_angle();
  inline ::CMsgQAngle* release_angle();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_FixAngle)
 private:
  inline void set_has_relative();
  inline void clear_has_relative();
  inline void set_has_angle();
  inline void clear_has_angle();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::CMsgQAngle* angle_;
  bool relative_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_FixAngle* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_CrosshairAngle : public ::google::protobuf::Message {
 public:
  CSVCMsg_CrosshairAngle();
  virtual ~CSVCMsg_CrosshairAngle();
  
  CSVCMsg_CrosshairAngle(const CSVCMsg_CrosshairAngle& from);
  
  inline CSVCMsg_CrosshairAngle& operator=(const CSVCMsg_CrosshairAngle& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_CrosshairAngle& default_instance();
  
  void Swap(CSVCMsg_CrosshairAngle* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_CrosshairAngle* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_CrosshairAngle& from);
  void MergeFrom(const CSVCMsg_CrosshairAngle& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional .CMsgQAngle angle = 1;
  inline bool has_angle() const;
  inline void clear_angle();
  static const int kAngleFieldNumber = 1;
  inline const ::CMsgQAngle& angle() const;
  inline ::CMsgQAngle* mutable_angle();
  inline ::CMsgQAngle* release_angle();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_CrosshairAngle)
 private:
  inline void set_has_angle();
  inline void clear_has_angle();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::CMsgQAngle* angle_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_CrosshairAngle* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_BSPDecal : public ::google::protobuf::Message {
 public:
  CSVCMsg_BSPDecal();
  virtual ~CSVCMsg_BSPDecal();
  
  CSVCMsg_BSPDecal(const CSVCMsg_BSPDecal& from);
  
  inline CSVCMsg_BSPDecal& operator=(const CSVCMsg_BSPDecal& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_BSPDecal& default_instance();
  
  void Swap(CSVCMsg_BSPDecal* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_BSPDecal* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_BSPDecal& from);
  void MergeFrom(const CSVCMsg_BSPDecal& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional .CMsgVector pos = 1;
  inline bool has_pos() const;
  inline void clear_pos();
  static const int kPosFieldNumber = 1;
  inline const ::CMsgVector& pos() const;
  inline ::CMsgVector* mutable_pos();
  inline ::CMsgVector* release_pos();
  
  // optional int32 decal_texture_index = 2;
  inline bool has_decal_texture_index() const;
  inline void clear_decal_texture_index();
  static const int kDecalTextureIndexFieldNumber = 2;
  inline ::google::protobuf::int32 decal_texture_index() const;
  inline void set_decal_texture_index(::google::protobuf::int32 value);
  
  // optional int32 entity_index = 3;
  inline bool has_entity_index() const;
  inline void clear_entity_index();
  static const int kEntityIndexFieldNumber = 3;
  inline ::google::protobuf::int32 entity_index() const;
  inline void set_entity_index(::google::protobuf::int32 value);
  
  // optional int32 model_index = 4;
  inline bool has_model_index() const;
  inline void clear_model_index();
  static const int kModelIndexFieldNumber = 4;
  inline ::google::protobuf::int32 model_index() const;
  inline void set_model_index(::google::protobuf::int32 value);
  
  // optional bool low_priority = 5;
  inline bool has_low_priority() const;
  inline void clear_low_priority();
  static const int kLowPriorityFieldNumber = 5;
  inline bool low_priority() const;
  inline void set_low_priority(bool value);
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_BSPDecal)
 private:
  inline void set_has_pos();
  inline void clear_has_pos();
  inline void set_has_decal_texture_index();
  inline void clear_has_decal_texture_index();
  inline void set_has_entity_index();
  inline void clear_has_entity_index();
  inline void set_has_model_index();
  inline void clear_has_model_index();
  inline void set_has_low_priority();
  inline void clear_has_low_priority();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::CMsgVector* pos_;
  ::google::protobuf::int32 decal_texture_index_;
  ::google::protobuf::int32 entity_index_;
  ::google::protobuf::int32 model_index_;
  bool low_priority_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_BSPDecal* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_SplitScreen : public ::google::protobuf::Message {
 public:
  CSVCMsg_SplitScreen();
  virtual ~CSVCMsg_SplitScreen();
  
  CSVCMsg_SplitScreen(const CSVCMsg_SplitScreen& from);
  
  inline CSVCMsg_SplitScreen& operator=(const CSVCMsg_SplitScreen& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_SplitScreen& default_instance();
  
  void Swap(CSVCMsg_SplitScreen* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_SplitScreen* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_SplitScreen& from);
  void MergeFrom(const CSVCMsg_SplitScreen& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional .ESplitScreenMessageType type = 1 [default = MSG_SPLITSCREEN_ADDUSER];
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 1;
  inline ESplitScreenMessageType type() const;
  inline void set_type(ESplitScreenMessageType value);
  
  // optional int32 slot = 2;
  inline bool has_slot() const;
  inline void clear_slot();
  static const int kSlotFieldNumber = 2;
  inline ::google::protobuf::int32 slot() const;
  inline void set_slot(::google::protobuf::int32 value);
  
  // optional int32 player_index = 3;
  inline bool has_player_index() const;
  inline void clear_player_index();
  static const int kPlayerIndexFieldNumber = 3;
  inline ::google::protobuf::int32 player_index() const;
  inline void set_player_index(::google::protobuf::int32 value);
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_SplitScreen)
 private:
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_slot();
  inline void clear_has_slot();
  inline void set_has_player_index();
  inline void clear_has_player_index();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  int type_;
  ::google::protobuf::int32 slot_;
  ::google::protobuf::int32 player_index_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_SplitScreen* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_GetCvarValue : public ::google::protobuf::Message {
 public:
  CSVCMsg_GetCvarValue();
  virtual ~CSVCMsg_GetCvarValue();
  
  CSVCMsg_GetCvarValue(const CSVCMsg_GetCvarValue& from);
  
  inline CSVCMsg_GetCvarValue& operator=(const CSVCMsg_GetCvarValue& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_GetCvarValue& default_instance();
  
  void Swap(CSVCMsg_GetCvarValue* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_GetCvarValue* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_GetCvarValue& from);
  void MergeFrom(const CSVCMsg_GetCvarValue& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 cookie = 1;
  inline bool has_cookie() const;
  inline void clear_cookie();
  static const int kCookieFieldNumber = 1;
  inline ::google::protobuf::int32 cookie() const;
  inline void set_cookie(::google::protobuf::int32 value);
  
  // optional string cvar_name = 2;
  inline bool has_cvar_name() const;
  inline void clear_cvar_name();
  static const int kCvarNameFieldNumber = 2;
  inline const ::std::string& cvar_name() const;
  inline void set_cvar_name(const ::std::string& value);
  inline void set_cvar_name(const char* value);
  inline void set_cvar_name(const char* value, size_t size);
  inline ::std::string* mutable_cvar_name();
  inline ::std::string* release_cvar_name();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_GetCvarValue)
 private:
  inline void set_has_cookie();
  inline void clear_has_cookie();
  inline void set_has_cvar_name();
  inline void clear_has_cvar_name();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* cvar_name_;
  ::google::protobuf::int32 cookie_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_GetCvarValue* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_Menu : public ::google::protobuf::Message {
 public:
  CSVCMsg_Menu();
  virtual ~CSVCMsg_Menu();
  
  CSVCMsg_Menu(const CSVCMsg_Menu& from);
  
  inline CSVCMsg_Menu& operator=(const CSVCMsg_Menu& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_Menu& default_instance();
  
  void Swap(CSVCMsg_Menu* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_Menu* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_Menu& from);
  void MergeFrom(const CSVCMsg_Menu& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 dialog_type = 1;
  inline bool has_dialog_type() const;
  inline void clear_dialog_type();
  static const int kDialogTypeFieldNumber = 1;
  inline ::google::protobuf::int32 dialog_type() const;
  inline void set_dialog_type(::google::protobuf::int32 value);
  
  // optional bytes menu_key_values = 2;
  inline bool has_menu_key_values() const;
  inline void clear_menu_key_values();
  static const int kMenuKeyValuesFieldNumber = 2;
  inline const ::std::string& menu_key_values() const;
  inline void set_menu_key_values(const ::std::string& value);
  inline void set_menu_key_values(const char* value);
  inline void set_menu_key_values(const void* value, size_t size);
  inline ::std::string* mutable_menu_key_values();
  inline ::std::string* release_menu_key_values();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_Menu)
 private:
  inline void set_has_dialog_type();
  inline void clear_has_dialog_type();
  inline void set_has_menu_key_values();
  inline void clear_has_menu_key_values();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* menu_key_values_;
  ::google::protobuf::int32 dialog_type_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_Menu* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_SendTable_sendprop_t : public ::google::protobuf::Message {
 public:
  CSVCMsg_SendTable_sendprop_t();
  virtual ~CSVCMsg_SendTable_sendprop_t();
  
  CSVCMsg_SendTable_sendprop_t(const CSVCMsg_SendTable_sendprop_t& from);
  
  inline CSVCMsg_SendTable_sendprop_t& operator=(const CSVCMsg_SendTable_sendprop_t& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_SendTable_sendprop_t& default_instance();
  
  void Swap(CSVCMsg_SendTable_sendprop_t* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_SendTable_sendprop_t* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_SendTable_sendprop_t& from);
  void MergeFrom(const CSVCMsg_SendTable_sendprop_t& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 type = 1;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 1;
  inline ::google::protobuf::int32 type() const;
  inline void set_type(::google::protobuf::int32 value);
  
  // optional string var_name = 2;
  inline bool has_var_name() const;
  inline void clear_var_name();
  static const int kVarNameFieldNumber = 2;
  inline const ::std::string& var_name() const;
  inline void set_var_name(const ::std::string& value);
  inline void set_var_name(const char* value);
  inline void set_var_name(const char* value, size_t size);
  inline ::std::string* mutable_var_name();
  inline ::std::string* release_var_name();
  
  // optional int32 flags = 3;
  inline bool has_flags() const;
  inline void clear_flags();
  static const int kFlagsFieldNumber = 3;
  inline ::google::protobuf::int32 flags() const;
  inline void set_flags(::google::protobuf::int32 value);
  
  // optional int32 priority = 4;
  inline bool has_priority() const;
  inline void clear_priority();
  static const int kPriorityFieldNumber = 4;
  inline ::google::protobuf::int32 priority() const;
  inline void set_priority(::google::protobuf::int32 value);
  
  // optional string dt_name = 5;
  inline bool has_dt_name() const;
  inline void clear_dt_name();
  static const int kDtNameFieldNumber = 5;
  inline const ::std::string& dt_name() const;
  inline void set_dt_name(const ::std::string& value);
  inline void set_dt_name(const char* value);
  inline void set_dt_name(const char* value, size_t size);
  inline ::std::string* mutable_dt_name();
  inline ::std::string* release_dt_name();
  
  // optional int32 num_elements = 6;
  inline bool has_num_elements() const;
  inline void clear_num_elements();
  static const int kNumElementsFieldNumber = 6;
  inline ::google::protobuf::int32 num_elements() const;
  inline void set_num_elements(::google::protobuf::int32 value);
  
  // optional float low_value = 7;
  inline bool has_low_value() const;
  inline void clear_low_value();
  static const int kLowValueFieldNumber = 7;
  inline float low_value() const;
  inline void set_low_value(float value);
  
  // optional float high_value = 8;
  inline bool has_high_value() const;
  inline void clear_high_value();
  static const int kHighValueFieldNumber = 8;
  inline float high_value() const;
  inline void set_high_value(float value);
  
  // optional int32 num_bits = 9;
  inline bool has_num_bits() const;
  inline void clear_num_bits();
  static const int kNumBitsFieldNumber = 9;
  inline ::google::protobuf::int32 num_bits() const;
  inline void set_num_bits(::google::protobuf::int32 value);
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_SendTable.sendprop_t)
 private:
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_var_name();
  inline void clear_has_var_name();
  inline void set_has_flags();
  inline void clear_has_flags();
  inline void set_has_priority();
  inline void clear_has_priority();
  inline void set_has_dt_name();
  inline void clear_has_dt_name();
  inline void set_has_num_elements();
  inline void clear_has_num_elements();
  inline void set_has_low_value();
  inline void clear_has_low_value();
  inline void set_has_high_value();
  inline void clear_has_high_value();
  inline void set_has_num_bits();
  inline void clear_has_num_bits();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* var_name_;
  ::google::protobuf::int32 type_;
  ::google::protobuf::int32 flags_;
  ::std::string* dt_name_;
  ::google::protobuf::int32 priority_;
  ::google::protobuf::int32 num_elements_;
  float low_value_;
  float high_value_;
  ::google::protobuf::int32 num_bits_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_SendTable_sendprop_t* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_SendTable : public ::google::protobuf::Message {
 public:
  CSVCMsg_SendTable();
  virtual ~CSVCMsg_SendTable();
  
  CSVCMsg_SendTable(const CSVCMsg_SendTable& from);
  
  inline CSVCMsg_SendTable& operator=(const CSVCMsg_SendTable& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_SendTable& default_instance();
  
  void Swap(CSVCMsg_SendTable* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_SendTable* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_SendTable& from);
  void MergeFrom(const CSVCMsg_SendTable& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef CSVCMsg_SendTable_sendprop_t sendprop_t;
  
  // accessors -------------------------------------------------------
  
  // optional bool is_end = 1;
  inline bool has_is_end() const;
  inline void clear_is_end();
  static const int kIsEndFieldNumber = 1;
  inline bool is_end() const;
  inline void set_is_end(bool value);
  
  // optional string net_table_name = 2;
  inline bool has_net_table_name() const;
  inline void clear_net_table_name();
  static const int kNetTableNameFieldNumber = 2;
  inline const ::std::string& net_table_name() const;
  inline void set_net_table_name(const ::std::string& value);
  inline void set_net_table_name(const char* value);
  inline void set_net_table_name(const char* value, size_t size);
  inline ::std::string* mutable_net_table_name();
  inline ::std::string* release_net_table_name();
  
  // optional bool needs_decoder = 3;
  inline bool has_needs_decoder() const;
  inline void clear_needs_decoder();
  static const int kNeedsDecoderFieldNumber = 3;
  inline bool needs_decoder() const;
  inline void set_needs_decoder(bool value);
  
  // repeated .CSVCMsg_SendTable.sendprop_t props = 4;
  inline int props_size() const;
  inline void clear_props();
  static const int kPropsFieldNumber = 4;
  inline const ::CSVCMsg_SendTable_sendprop_t& props(int index) const;
  inline ::CSVCMsg_SendTable_sendprop_t* mutable_props(int index);
  inline ::CSVCMsg_SendTable_sendprop_t* add_props();
  inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsg_SendTable_sendprop_t >&
      props() const;
  inline ::google::protobuf::RepeatedPtrField< ::CSVCMsg_SendTable_sendprop_t >*
      mutable_props();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_SendTable)
 private:
  inline void set_has_is_end();
  inline void clear_has_is_end();
  inline void set_has_net_table_name();
  inline void clear_has_net_table_name();
  inline void set_has_needs_decoder();
  inline void clear_has_needs_decoder();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* net_table_name_;
  ::google::protobuf::RepeatedPtrField< ::CSVCMsg_SendTable_sendprop_t > props_;
  bool is_end_;
  bool needs_decoder_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_SendTable* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_GameEvent_key_t : public ::google::protobuf::Message {
 public:
  CSVCMsg_GameEvent_key_t();
  virtual ~CSVCMsg_GameEvent_key_t();
  
  CSVCMsg_GameEvent_key_t(const CSVCMsg_GameEvent_key_t& from);
  
  inline CSVCMsg_GameEvent_key_t& operator=(const CSVCMsg_GameEvent_key_t& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_GameEvent_key_t& default_instance();
  
  void Swap(CSVCMsg_GameEvent_key_t* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_GameEvent_key_t* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_GameEvent_key_t& from);
  void MergeFrom(const CSVCMsg_GameEvent_key_t& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 type = 1;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 1;
  inline ::google::protobuf::int32 type() const;
  inline void set_type(::google::protobuf::int32 value);
  
  // optional string val_string = 2;
  inline bool has_val_string() const;
  inline void clear_val_string();
  static const int kValStringFieldNumber = 2;
  inline const ::std::string& val_string() const;
  inline void set_val_string(const ::std::string& value);
  inline void set_val_string(const char* value);
  inline void set_val_string(const char* value, size_t size);
  inline ::std::string* mutable_val_string();
  inline ::std::string* release_val_string();
  
  // optional float val_float = 3;
  inline bool has_val_float() const;
  inline void clear_val_float();
  static const int kValFloatFieldNumber = 3;
  inline float val_float() const;
  inline void set_val_float(float value);
  
  // optional int32 val_long = 4;
  inline bool has_val_long() const;
  inline void clear_val_long();
  static const int kValLongFieldNumber = 4;
  inline ::google::protobuf::int32 val_long() const;
  inline void set_val_long(::google::protobuf::int32 value);
  
  // optional int32 val_short = 5;
  inline bool has_val_short() const;
  inline void clear_val_short();
  static const int kValShortFieldNumber = 5;
  inline ::google::protobuf::int32 val_short() const;
  inline void set_val_short(::google::protobuf::int32 value);
  
  // optional int32 val_byte = 6;
  inline bool has_val_byte() const;
  inline void clear_val_byte();
  static const int kValByteFieldNumber = 6;
  inline ::google::protobuf::int32 val_byte() const;
  inline void set_val_byte(::google::protobuf::int32 value);
  
  // optional bool val_bool = 7;
  inline bool has_val_bool() const;
  inline void clear_val_bool();
  static const int kValBoolFieldNumber = 7;
  inline bool val_bool() const;
  inline void set_val_bool(bool value);
  
  // optional uint64 val_uint64 = 8;
  inline bool has_val_uint64() const;
  inline void clear_val_uint64();
  static const int kValUint64FieldNumber = 8;
  inline ::google::protobuf::uint64 val_uint64() const;
  inline void set_val_uint64(::google::protobuf::uint64 value);
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_GameEvent.key_t)
 private:
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_val_string();
  inline void clear_has_val_string();
  inline void set_has_val_float();
  inline void clear_has_val_float();
  inline void set_has_val_long();
  inline void clear_has_val_long();
  inline void set_has_val_short();
  inline void clear_has_val_short();
  inline void set_has_val_byte();
  inline void clear_has_val_byte();
  inline void set_has_val_bool();
  inline void clear_has_val_bool();
  inline void set_has_val_uint64();
  inline void clear_has_val_uint64();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* val_string_;
  ::google::protobuf::int32 type_;
  float val_float_;
  ::google::protobuf::int32 val_long_;
  ::google::protobuf::int32 val_short_;
  ::google::protobuf::int32 val_byte_;
  bool val_bool_;
  ::google::protobuf::uint64 val_uint64_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_GameEvent_key_t* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_GameEvent : public ::google::protobuf::Message {
 public:
  CSVCMsg_GameEvent();
  virtual ~CSVCMsg_GameEvent();
  
  CSVCMsg_GameEvent(const CSVCMsg_GameEvent& from);
  
  inline CSVCMsg_GameEvent& operator=(const CSVCMsg_GameEvent& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_GameEvent& default_instance();
  
  void Swap(CSVCMsg_GameEvent* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_GameEvent* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_GameEvent& from);
  void MergeFrom(const CSVCMsg_GameEvent& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef CSVCMsg_GameEvent_key_t key_t;
  
  // accessors -------------------------------------------------------
  
  // optional string event_name = 1;
  inline bool has_event_name() const;
  inline void clear_event_name();
  static const int kEventNameFieldNumber = 1;
  inline const ::std::string& event_name() const;
  inline void set_event_name(const ::std::string& value);
  inline void set_event_name(const char* value);
  inline void set_event_name(const char* value, size_t size);
  inline ::std::string* mutable_event_name();
  inline ::std::string* release_event_name();
  
  // optional int32 eventid = 2;
  inline bool has_eventid() const;
  inline void clear_eventid();
  static const int kEventidFieldNumber = 2;
  inline ::google::protobuf::int32 eventid() const;
  inline void set_eventid(::google::protobuf::int32 value);
  
  // repeated .CSVCMsg_GameEvent.key_t keys = 3;
  inline int keys_size() const;
  inline void clear_keys();
  static const int kKeysFieldNumber = 3;
  inline const ::CSVCMsg_GameEvent_key_t& keys(int index) const;
  inline ::CSVCMsg_GameEvent_key_t* mutable_keys(int index);
  inline ::CSVCMsg_GameEvent_key_t* add_keys();
  inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsg_GameEvent_key_t >&
      keys() const;
  inline ::google::protobuf::RepeatedPtrField< ::CSVCMsg_GameEvent_key_t >*
      mutable_keys();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_GameEvent)
 private:
  inline void set_has_event_name();
  inline void clear_has_event_name();
  inline void set_has_eventid();
  inline void clear_has_eventid();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* event_name_;
  ::google::protobuf::RepeatedPtrField< ::CSVCMsg_GameEvent_key_t > keys_;
  ::google::protobuf::int32 eventid_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_GameEvent* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_GameEventList_key_t : public ::google::protobuf::Message {
 public:
  CSVCMsg_GameEventList_key_t();
  virtual ~CSVCMsg_GameEventList_key_t();
  
  CSVCMsg_GameEventList_key_t(const CSVCMsg_GameEventList_key_t& from);
  
  inline CSVCMsg_GameEventList_key_t& operator=(const CSVCMsg_GameEventList_key_t& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_GameEventList_key_t& default_instance();
  
  void Swap(CSVCMsg_GameEventList_key_t* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_GameEventList_key_t* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_GameEventList_key_t& from);
  void MergeFrom(const CSVCMsg_GameEventList_key_t& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 type = 1;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 1;
  inline ::google::protobuf::int32 type() const;
  inline void set_type(::google::protobuf::int32 value);
  
  // optional string name = 2;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 2;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_GameEventList.key_t)
 private:
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_name();
  inline void clear_has_name();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* name_;
  ::google::protobuf::int32 type_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_GameEventList_key_t* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_GameEventList_descriptor_t : public ::google::protobuf::Message {
 public:
  CSVCMsg_GameEventList_descriptor_t();
  virtual ~CSVCMsg_GameEventList_descriptor_t();
  
  CSVCMsg_GameEventList_descriptor_t(const CSVCMsg_GameEventList_descriptor_t& from);
  
  inline CSVCMsg_GameEventList_descriptor_t& operator=(const CSVCMsg_GameEventList_descriptor_t& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_GameEventList_descriptor_t& default_instance();
  
  void Swap(CSVCMsg_GameEventList_descriptor_t* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_GameEventList_descriptor_t* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_GameEventList_descriptor_t& from);
  void MergeFrom(const CSVCMsg_GameEventList_descriptor_t& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 eventid = 1;
  inline bool has_eventid() const;
  inline void clear_eventid();
  static const int kEventidFieldNumber = 1;
  inline ::google::protobuf::int32 eventid() const;
  inline void set_eventid(::google::protobuf::int32 value);
  
  // optional string name = 2;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 2;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  
  // repeated .CSVCMsg_GameEventList.key_t keys = 3;
  inline int keys_size() const;
  inline void clear_keys();
  static const int kKeysFieldNumber = 3;
  inline const ::CSVCMsg_GameEventList_key_t& keys(int index) const;
  inline ::CSVCMsg_GameEventList_key_t* mutable_keys(int index);
  inline ::CSVCMsg_GameEventList_key_t* add_keys();
  inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsg_GameEventList_key_t >&
      keys() const;
  inline ::google::protobuf::RepeatedPtrField< ::CSVCMsg_GameEventList_key_t >*
      mutable_keys();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_GameEventList.descriptor_t)
 private:
  inline void set_has_eventid();
  inline void clear_has_eventid();
  inline void set_has_name();
  inline void clear_has_name();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* name_;
  ::google::protobuf::RepeatedPtrField< ::CSVCMsg_GameEventList_key_t > keys_;
  ::google::protobuf::int32 eventid_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_GameEventList_descriptor_t* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_GameEventList : public ::google::protobuf::Message {
 public:
  CSVCMsg_GameEventList();
  virtual ~CSVCMsg_GameEventList();
  
  CSVCMsg_GameEventList(const CSVCMsg_GameEventList& from);
  
  inline CSVCMsg_GameEventList& operator=(const CSVCMsg_GameEventList& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_GameEventList& default_instance();
  
  void Swap(CSVCMsg_GameEventList* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_GameEventList* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_GameEventList& from);
  void MergeFrom(const CSVCMsg_GameEventList& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef CSVCMsg_GameEventList_key_t key_t;
  typedef CSVCMsg_GameEventList_descriptor_t descriptor_t;
  
  // accessors -------------------------------------------------------
  
  // repeated .CSVCMsg_GameEventList.descriptor_t descriptors = 1;
  inline int descriptors_size() const;
  inline void clear_descriptors();
  static const int kDescriptorsFieldNumber = 1;
  inline const ::CSVCMsg_GameEventList_descriptor_t& descriptors(int index) const;
  inline ::CSVCMsg_GameEventList_descriptor_t* mutable_descriptors(int index);
  inline ::CSVCMsg_GameEventList_descriptor_t* add_descriptors();
  inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsg_GameEventList_descriptor_t >&
      descriptors() const;
  inline ::google::protobuf::RepeatedPtrField< ::CSVCMsg_GameEventList_descriptor_t >*
      mutable_descriptors();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_GameEventList)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::CSVCMsg_GameEventList_descriptor_t > descriptors_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_GameEventList* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_PacketEntities : public ::google::protobuf::Message {
 public:
  CSVCMsg_PacketEntities();
  virtual ~CSVCMsg_PacketEntities();
  
  CSVCMsg_PacketEntities(const CSVCMsg_PacketEntities& from);
  
  inline CSVCMsg_PacketEntities& operator=(const CSVCMsg_PacketEntities& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_PacketEntities& default_instance();
  
  void Swap(CSVCMsg_PacketEntities* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_PacketEntities* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_PacketEntities& from);
  void MergeFrom(const CSVCMsg_PacketEntities& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 max_entries = 1;
  inline bool has_max_entries() const;
  inline void clear_max_entries();
  static const int kMaxEntriesFieldNumber = 1;
  inline ::google::protobuf::int32 max_entries() const;
  inline void set_max_entries(::google::protobuf::int32 value);
  
  // optional int32 updated_entries = 2;
  inline bool has_updated_entries() const;
  inline void clear_updated_entries();
  static const int kUpdatedEntriesFieldNumber = 2;
  inline ::google::protobuf::int32 updated_entries() const;
  inline void set_updated_entries(::google::protobuf::int32 value);
  
  // optional bool is_delta = 3;
  inline bool has_is_delta() const;
  inline void clear_is_delta();
  static const int kIsDeltaFieldNumber = 3;
  inline bool is_delta() const;
  inline void set_is_delta(bool value);
  
  // optional bool update_baseline = 4;
  inline bool has_update_baseline() const;
  inline void clear_update_baseline();
  static const int kUpdateBaselineFieldNumber = 4;
  inline bool update_baseline() const;
  inline void set_update_baseline(bool value);
  
  // optional int32 baseline = 5;
  inline bool has_baseline() const;
  inline void clear_baseline();
  static const int kBaselineFieldNumber = 5;
  inline ::google::protobuf::int32 baseline() const;
  inline void set_baseline(::google::protobuf::int32 value);
  
  // optional int32 delta_from = 6;
  inline bool has_delta_from() const;
  inline void clear_delta_from();
  static const int kDeltaFromFieldNumber = 6;
  inline ::google::protobuf::int32 delta_from() const;
  inline void set_delta_from(::google::protobuf::int32 value);
  
  // optional bytes entity_data = 7;
  inline bool has_entity_data() const;
  inline void clear_entity_data();
  static const int kEntityDataFieldNumber = 7;
  inline const ::std::string& entity_data() const;
  inline void set_entity_data(const ::std::string& value);
  inline void set_entity_data(const char* value);
  inline void set_entity_data(const void* value, size_t size);
  inline ::std::string* mutable_entity_data();
  inline ::std::string* release_entity_data();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_PacketEntities)
 private:
  inline void set_has_max_entries();
  inline void clear_has_max_entries();
  inline void set_has_updated_entries();
  inline void clear_has_updated_entries();
  inline void set_has_is_delta();
  inline void clear_has_is_delta();
  inline void set_has_update_baseline();
  inline void clear_has_update_baseline();
  inline void set_has_baseline();
  inline void clear_has_baseline();
  inline void set_has_delta_from();
  inline void clear_has_delta_from();
  inline void set_has_entity_data();
  inline void clear_has_entity_data();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::int32 max_entries_;
  ::google::protobuf::int32 updated_entries_;
  bool is_delta_;
  bool update_baseline_;
  ::google::protobuf::int32 baseline_;
  ::std::string* entity_data_;
  ::google::protobuf::int32 delta_from_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_PacketEntities* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_TempEntities : public ::google::protobuf::Message {
 public:
  CSVCMsg_TempEntities();
  virtual ~CSVCMsg_TempEntities();
  
  CSVCMsg_TempEntities(const CSVCMsg_TempEntities& from);
  
  inline CSVCMsg_TempEntities& operator=(const CSVCMsg_TempEntities& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_TempEntities& default_instance();
  
  void Swap(CSVCMsg_TempEntities* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_TempEntities* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_TempEntities& from);
  void MergeFrom(const CSVCMsg_TempEntities& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional bool reliable = 1;
  inline bool has_reliable() const;
  inline void clear_reliable();
  static const int kReliableFieldNumber = 1;
  inline bool reliable() const;
  inline void set_reliable(bool value);
  
  // optional int32 num_entries = 2;
  inline bool has_num_entries() const;
  inline void clear_num_entries();
  static const int kNumEntriesFieldNumber = 2;
  inline ::google::protobuf::int32 num_entries() const;
  inline void set_num_entries(::google::protobuf::int32 value);
  
  // optional bytes entity_data = 3;
  inline bool has_entity_data() const;
  inline void clear_entity_data();
  static const int kEntityDataFieldNumber = 3;
  inline const ::std::string& entity_data() const;
  inline void set_entity_data(const ::std::string& value);
  inline void set_entity_data(const char* value);
  inline void set_entity_data(const void* value, size_t size);
  inline ::std::string* mutable_entity_data();
  inline ::std::string* release_entity_data();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_TempEntities)
 private:
  inline void set_has_reliable();
  inline void clear_has_reliable();
  inline void set_has_num_entries();
  inline void clear_has_num_entries();
  inline void set_has_entity_data();
  inline void clear_has_entity_data();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  bool reliable_;
  ::google::protobuf::int32 num_entries_;
  ::std::string* entity_data_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_TempEntities* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_CreateStringTable : public ::google::protobuf::Message {
 public:
  CSVCMsg_CreateStringTable();
  virtual ~CSVCMsg_CreateStringTable();
  
  CSVCMsg_CreateStringTable(const CSVCMsg_CreateStringTable& from);
  
  inline CSVCMsg_CreateStringTable& operator=(const CSVCMsg_CreateStringTable& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_CreateStringTable& default_instance();
  
  void Swap(CSVCMsg_CreateStringTable* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_CreateStringTable* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_CreateStringTable& from);
  void MergeFrom(const CSVCMsg_CreateStringTable& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  
  // optional int32 max_entries = 2;
  inline bool has_max_entries() const;
  inline void clear_max_entries();
  static const int kMaxEntriesFieldNumber = 2;
  inline ::google::protobuf::int32 max_entries() const;
  inline void set_max_entries(::google::protobuf::int32 value);
  
  // optional int32 num_entries = 3;
  inline bool has_num_entries() const;
  inline void clear_num_entries();
  static const int kNumEntriesFieldNumber = 3;
  inline ::google::protobuf::int32 num_entries() const;
  inline void set_num_entries(::google::protobuf::int32 value);
  
  // optional bool user_data_fixed_size = 4;
  inline bool has_user_data_fixed_size() const;
  inline void clear_user_data_fixed_size();
  static const int kUserDataFixedSizeFieldNumber = 4;
  inline bool user_data_fixed_size() const;
  inline void set_user_data_fixed_size(bool value);
  
  // optional int32 user_data_size = 5;
  inline bool has_user_data_size() const;
  inline void clear_user_data_size();
  static const int kUserDataSizeFieldNumber = 5;
  inline ::google::protobuf::int32 user_data_size() const;
  inline void set_user_data_size(::google::protobuf::int32 value);
  
  // optional int32 user_data_size_bits = 6;
  inline bool has_user_data_size_bits() const;
  inline void clear_user_data_size_bits();
  static const int kUserDataSizeBitsFieldNumber = 6;
  inline ::google::protobuf::int32 user_data_size_bits() const;
  inline void set_user_data_size_bits(::google::protobuf::int32 value);
  
  // optional int32 flags = 7;
  inline bool has_flags() const;
  inline void clear_flags();
  static const int kFlagsFieldNumber = 7;
  inline ::google::protobuf::int32 flags() const;
  inline void set_flags(::google::protobuf::int32 value);
  
  // optional bytes string_data = 8;
  inline bool has_string_data() const;
  inline void clear_string_data();
  static const int kStringDataFieldNumber = 8;
  inline const ::std::string& string_data() const;
  inline void set_string_data(const ::std::string& value);
  inline void set_string_data(const char* value);
  inline void set_string_data(const void* value, size_t size);
  inline ::std::string* mutable_string_data();
  inline ::std::string* release_string_data();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_CreateStringTable)
 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_max_entries();
  inline void clear_has_max_entries();
  inline void set_has_num_entries();
  inline void clear_has_num_entries();
  inline void set_has_user_data_fixed_size();
  inline void clear_has_user_data_fixed_size();
  inline void set_has_user_data_size();
  inline void clear_has_user_data_size();
  inline void set_has_user_data_size_bits();
  inline void clear_has_user_data_size_bits();
  inline void set_has_flags();
  inline void clear_has_flags();
  inline void set_has_string_data();
  inline void clear_has_string_data();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* name_;
  ::google::protobuf::int32 max_entries_;
  ::google::protobuf::int32 num_entries_;
  bool user_data_fixed_size_;
  ::google::protobuf::int32 user_data_size_;
  ::google::protobuf::int32 user_data_size_bits_;
  ::google::protobuf::int32 flags_;
  ::std::string* string_data_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_CreateStringTable* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_UpdateStringTable : public ::google::protobuf::Message {
 public:
  CSVCMsg_UpdateStringTable();
  virtual ~CSVCMsg_UpdateStringTable();
  
  CSVCMsg_UpdateStringTable(const CSVCMsg_UpdateStringTable& from);
  
  inline CSVCMsg_UpdateStringTable& operator=(const CSVCMsg_UpdateStringTable& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_UpdateStringTable& default_instance();
  
  void Swap(CSVCMsg_UpdateStringTable* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_UpdateStringTable* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_UpdateStringTable& from);
  void MergeFrom(const CSVCMsg_UpdateStringTable& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 table_id = 1;
  inline bool has_table_id() const;
  inline void clear_table_id();
  static const int kTableIdFieldNumber = 1;
  inline ::google::protobuf::int32 table_id() const;
  inline void set_table_id(::google::protobuf::int32 value);
  
  // optional int32 num_changed_entries = 2;
  inline bool has_num_changed_entries() const;
  inline void clear_num_changed_entries();
  static const int kNumChangedEntriesFieldNumber = 2;
  inline ::google::protobuf::int32 num_changed_entries() const;
  inline void set_num_changed_entries(::google::protobuf::int32 value);
  
  // optional bytes string_data = 3;
  inline bool has_string_data() const;
  inline void clear_string_data();
  static const int kStringDataFieldNumber = 3;
  inline const ::std::string& string_data() const;
  inline void set_string_data(const ::std::string& value);
  inline void set_string_data(const char* value);
  inline void set_string_data(const void* value, size_t size);
  inline ::std::string* mutable_string_data();
  inline ::std::string* release_string_data();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_UpdateStringTable)
 private:
  inline void set_has_table_id();
  inline void clear_has_table_id();
  inline void set_has_num_changed_entries();
  inline void clear_has_num_changed_entries();
  inline void set_has_string_data();
  inline void clear_has_string_data();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::int32 table_id_;
  ::google::protobuf::int32 num_changed_entries_;
  ::std::string* string_data_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_UpdateStringTable* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_UserMessage : public ::google::protobuf::Message {
 public:
  CSVCMsg_UserMessage();
  virtual ~CSVCMsg_UserMessage();
  
  CSVCMsg_UserMessage(const CSVCMsg_UserMessage& from);
  
  inline CSVCMsg_UserMessage& operator=(const CSVCMsg_UserMessage& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_UserMessage& default_instance();
  
  void Swap(CSVCMsg_UserMessage* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_UserMessage* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_UserMessage& from);
  void MergeFrom(const CSVCMsg_UserMessage& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 msg_type = 1;
  inline bool has_msg_type() const;
  inline void clear_msg_type();
  static const int kMsgTypeFieldNumber = 1;
  inline ::google::protobuf::int32 msg_type() const;
  inline void set_msg_type(::google::protobuf::int32 value);
  
  // optional bytes msg_data = 2;
  inline bool has_msg_data() const;
  inline void clear_msg_data();
  static const int kMsgDataFieldNumber = 2;
  inline const ::std::string& msg_data() const;
  inline void set_msg_data(const ::std::string& value);
  inline void set_msg_data(const char* value);
  inline void set_msg_data(const void* value, size_t size);
  inline ::std::string* mutable_msg_data();
  inline ::std::string* release_msg_data();
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_UserMessage)
 private:
  inline void set_has_msg_type();
  inline void clear_has_msg_type();
  inline void set_has_msg_data();
  inline void clear_has_msg_data();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* msg_data_;
  ::google::protobuf::int32 msg_type_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_UserMessage* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_VoiceData : public ::google::protobuf::Message {
 public:
  CSVCMsg_VoiceData();
  virtual ~CSVCMsg_VoiceData();
  
  CSVCMsg_VoiceData(const CSVCMsg_VoiceData& from);
  
  inline CSVCMsg_VoiceData& operator=(const CSVCMsg_VoiceData& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_VoiceData& default_instance();
  
  void Swap(CSVCMsg_VoiceData* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_VoiceData* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_VoiceData& from);
  void MergeFrom(const CSVCMsg_VoiceData& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 client = 1;
  inline bool has_client() const;
  inline void clear_client();
  static const int kClientFieldNumber = 1;
  inline ::google::protobuf::int32 client() const;
  inline void set_client(::google::protobuf::int32 value);
  
  // optional bool proximity = 2;
  inline bool has_proximity() const;
  inline void clear_proximity();
  static const int kProximityFieldNumber = 2;
  inline bool proximity() const;
  inline void set_proximity(bool value);
  
  // optional fixed64 xuid = 3;
  inline bool has_xuid() const;
  inline void clear_xuid();
  static const int kXuidFieldNumber = 3;
  inline ::google::protobuf::uint64 xuid() const;
  inline void set_xuid(::google::protobuf::uint64 value);
  
  // optional int32 audible_mask = 4;
  inline bool has_audible_mask() const;
  inline void clear_audible_mask();
  static const int kAudibleMaskFieldNumber = 4;
  inline ::google::protobuf::int32 audible_mask() const;
  inline void set_audible_mask(::google::protobuf::int32 value);
  
  // optional bytes voice_data = 5;
  inline bool has_voice_data() const;
  inline void clear_voice_data();
  static const int kVoiceDataFieldNumber = 5;
  inline const ::std::string& voice_data() const;
  inline void set_voice_data(const ::std::string& value);
  inline void set_voice_data(const char* value);
  inline void set_voice_data(const void* value, size_t size);
  inline ::std::string* mutable_voice_data();
  inline ::std::string* release_voice_data();
  
  // optional .VoiceDataFormat_t format = 6 [default = VOICEDATA_FORMAT_STEAM];
  inline bool has_format() const;
  inline void clear_format();
  static const int kFormatFieldNumber = 6;
  inline VoiceDataFormat_t format() const;
  inline void set_format(VoiceDataFormat_t value);
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_VoiceData)
 private:
  inline void set_has_client();
  inline void clear_has_client();
  inline void set_has_proximity();
  inline void clear_has_proximity();
  inline void set_has_xuid();
  inline void clear_has_xuid();
  inline void set_has_audible_mask();
  inline void clear_has_audible_mask();
  inline void set_has_voice_data();
  inline void clear_has_voice_data();
  inline void set_has_format();
  inline void clear_has_format();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::int32 client_;
  bool proximity_;
  ::google::protobuf::uint64 xuid_;
  ::std::string* voice_data_;
  ::google::protobuf::int32 audible_mask_;
  int format_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_VoiceData* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsgList_GameEvents_event_t : public ::google::protobuf::Message {
 public:
  CSVCMsgList_GameEvents_event_t();
  virtual ~CSVCMsgList_GameEvents_event_t();
  
  CSVCMsgList_GameEvents_event_t(const CSVCMsgList_GameEvents_event_t& from);
  
  inline CSVCMsgList_GameEvents_event_t& operator=(const CSVCMsgList_GameEvents_event_t& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsgList_GameEvents_event_t& default_instance();
  
  void Swap(CSVCMsgList_GameEvents_event_t* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsgList_GameEvents_event_t* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsgList_GameEvents_event_t& from);
  void MergeFrom(const CSVCMsgList_GameEvents_event_t& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 tick = 1;
  inline bool has_tick() const;
  inline void clear_tick();
  static const int kTickFieldNumber = 1;
  inline ::google::protobuf::int32 tick() const;
  inline void set_tick(::google::protobuf::int32 value);
  
  // optional .CSVCMsg_GameEvent event = 2;
  inline bool has_event() const;
  inline void clear_event();
  static const int kEventFieldNumber = 2;
  inline const ::CSVCMsg_GameEvent& event() const;
  inline ::CSVCMsg_GameEvent* mutable_event();
  inline ::CSVCMsg_GameEvent* release_event();
  
  // @@protoc_insertion_point(class_scope:CSVCMsgList_GameEvents.event_t)
 private:
  inline void set_has_tick();
  inline void clear_has_tick();
  inline void set_has_event();
  inline void clear_has_event();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::CSVCMsg_GameEvent* event_;
  ::google::protobuf::int32 tick_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsgList_GameEvents_event_t* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsgList_GameEvents : public ::google::protobuf::Message {
 public:
  CSVCMsgList_GameEvents();
  virtual ~CSVCMsgList_GameEvents();
  
  CSVCMsgList_GameEvents(const CSVCMsgList_GameEvents& from);
  
  inline CSVCMsgList_GameEvents& operator=(const CSVCMsgList_GameEvents& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsgList_GameEvents& default_instance();
  
  void Swap(CSVCMsgList_GameEvents* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsgList_GameEvents* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsgList_GameEvents& from);
  void MergeFrom(const CSVCMsgList_GameEvents& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef CSVCMsgList_GameEvents_event_t event_t;
  
  // accessors -------------------------------------------------------
  
  // repeated .CSVCMsgList_GameEvents.event_t events = 1;
  inline int events_size() const;
  inline void clear_events();
  static const int kEventsFieldNumber = 1;
  inline const ::CSVCMsgList_GameEvents_event_t& events(int index) const;
  inline ::CSVCMsgList_GameEvents_event_t* mutable_events(int index);
  inline ::CSVCMsgList_GameEvents_event_t* add_events();
  inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsgList_GameEvents_event_t >&
      events() const;
  inline ::google::protobuf::RepeatedPtrField< ::CSVCMsgList_GameEvents_event_t >*
      mutable_events();
  
  // @@protoc_insertion_point(class_scope:CSVCMsgList_GameEvents)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::CSVCMsgList_GameEvents_event_t > events_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsgList_GameEvents* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsgList_UserMessages_usermsg_t : public ::google::protobuf::Message {
 public:
  CSVCMsgList_UserMessages_usermsg_t();
  virtual ~CSVCMsgList_UserMessages_usermsg_t();
  
  CSVCMsgList_UserMessages_usermsg_t(const CSVCMsgList_UserMessages_usermsg_t& from);
  
  inline CSVCMsgList_UserMessages_usermsg_t& operator=(const CSVCMsgList_UserMessages_usermsg_t& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsgList_UserMessages_usermsg_t& default_instance();
  
  void Swap(CSVCMsgList_UserMessages_usermsg_t* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsgList_UserMessages_usermsg_t* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsgList_UserMessages_usermsg_t& from);
  void MergeFrom(const CSVCMsgList_UserMessages_usermsg_t& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 tick = 1;
  inline bool has_tick() const;
  inline void clear_tick();
  static const int kTickFieldNumber = 1;
  inline ::google::protobuf::int32 tick() const;
  inline void set_tick(::google::protobuf::int32 value);
  
  // optional .CSVCMsg_UserMessage msg = 2;
  inline bool has_msg() const;
  inline void clear_msg();
  static const int kMsgFieldNumber = 2;
  inline const ::CSVCMsg_UserMessage& msg() const;
  inline ::CSVCMsg_UserMessage* mutable_msg();
  inline ::CSVCMsg_UserMessage* release_msg();
  
  // @@protoc_insertion_point(class_scope:CSVCMsgList_UserMessages.usermsg_t)
 private:
  inline void set_has_tick();
  inline void clear_has_tick();
  inline void set_has_msg();
  inline void clear_has_msg();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::CSVCMsg_UserMessage* msg_;
  ::google::protobuf::int32 tick_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsgList_UserMessages_usermsg_t* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsgList_UserMessages : public ::google::protobuf::Message {
 public:
  CSVCMsgList_UserMessages();
  virtual ~CSVCMsgList_UserMessages();
  
  CSVCMsgList_UserMessages(const CSVCMsgList_UserMessages& from);
  
  inline CSVCMsgList_UserMessages& operator=(const CSVCMsgList_UserMessages& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsgList_UserMessages& default_instance();
  
  void Swap(CSVCMsgList_UserMessages* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsgList_UserMessages* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsgList_UserMessages& from);
  void MergeFrom(const CSVCMsgList_UserMessages& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef CSVCMsgList_UserMessages_usermsg_t usermsg_t;
  
  // accessors -------------------------------------------------------
  
  // repeated .CSVCMsgList_UserMessages.usermsg_t usermsgs = 1;
  inline int usermsgs_size() const;
  inline void clear_usermsgs();
  static const int kUsermsgsFieldNumber = 1;
  inline const ::CSVCMsgList_UserMessages_usermsg_t& usermsgs(int index) const;
  inline ::CSVCMsgList_UserMessages_usermsg_t* mutable_usermsgs(int index);
  inline ::CSVCMsgList_UserMessages_usermsg_t* add_usermsgs();
  inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsgList_UserMessages_usermsg_t >&
      usermsgs() const;
  inline ::google::protobuf::RepeatedPtrField< ::CSVCMsgList_UserMessages_usermsg_t >*
      mutable_usermsgs();
  
  // @@protoc_insertion_point(class_scope:CSVCMsgList_UserMessages)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::CSVCMsgList_UserMessages_usermsg_t > usermsgs_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsgList_UserMessages* default_instance_;
};
// -------------------------------------------------------------------

class CSVCMsg_PacketReliable : public ::google::protobuf::Message {
 public:
  CSVCMsg_PacketReliable();
  virtual ~CSVCMsg_PacketReliable();
  
  CSVCMsg_PacketReliable(const CSVCMsg_PacketReliable& from);
  
  inline CSVCMsg_PacketReliable& operator=(const CSVCMsg_PacketReliable& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CSVCMsg_PacketReliable& default_instance();
  
  void Swap(CSVCMsg_PacketReliable* other);
  
  // implements Message ----------------------------------------------
  
  CSVCMsg_PacketReliable* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CSVCMsg_PacketReliable& from);
  void MergeFrom(const CSVCMsg_PacketReliable& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional int32 tick = 1;
  inline bool has_tick() const;
  inline void clear_tick();
  static const int kTickFieldNumber = 1;
  inline ::google::protobuf::int32 tick() const;
  inline void set_tick(::google::protobuf::int32 value);
  
  // optional int32 messagessize = 2;
  inline bool has_messagessize() const;
  inline void clear_messagessize();
  static const int kMessagessizeFieldNumber = 2;
  inline ::google::protobuf::int32 messagessize() const;
  inline void set_messagessize(::google::protobuf::int32 value);
  
  // @@protoc_insertion_point(class_scope:CSVCMsg_PacketReliable)
 private:
  inline void set_has_tick();
  inline void clear_has_tick();
  inline void set_has_messagessize();
  inline void clear_has_messagessize();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::int32 tick_;
  ::google::protobuf::int32 messagessize_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_netmessages_2eproto();
  friend void protobuf_AssignDesc_netmessages_2eproto();
  friend void protobuf_ShutdownFile_netmessages_2eproto();
  
  void InitAsDefaultInstance();
  static CSVCMsg_PacketReliable* default_instance_;
};
// ===================================================================


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

// CMsgVector

// optional float x = 1;
inline bool CMsgVector::has_x() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CMsgVector::set_has_x() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CMsgVector::clear_has_x() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CMsgVector::clear_x() {
  x_ = 0;
  clear_has_x();
}
inline float CMsgVector::x() const {
  return x_;
}
inline void CMsgVector::set_x(float value) {
  set_has_x();
  x_ = value;
}

// optional float y = 2;
inline bool CMsgVector::has_y() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CMsgVector::set_has_y() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CMsgVector::clear_has_y() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CMsgVector::clear_y() {
  y_ = 0;
  clear_has_y();
}
inline float CMsgVector::y() const {
  return y_;
}
inline void CMsgVector::set_y(float value) {
  set_has_y();
  y_ = value;
}

// optional float z = 3;
inline bool CMsgVector::has_z() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CMsgVector::set_has_z() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CMsgVector::clear_has_z() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CMsgVector::clear_z() {
  z_ = 0;
  clear_has_z();
}
inline float CMsgVector::z() const {
  return z_;
}
inline void CMsgVector::set_z(float value) {
  set_has_z();
  z_ = value;
}

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

// CMsgVector2D

// optional float x = 1;
inline bool CMsgVector2D::has_x() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CMsgVector2D::set_has_x() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CMsgVector2D::clear_has_x() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CMsgVector2D::clear_x() {
  x_ = 0;
  clear_has_x();
}
inline float CMsgVector2D::x() const {
  return x_;
}
inline void CMsgVector2D::set_x(float value) {
  set_has_x();
  x_ = value;
}

// optional float y = 2;
inline bool CMsgVector2D::has_y() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CMsgVector2D::set_has_y() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CMsgVector2D::clear_has_y() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CMsgVector2D::clear_y() {
  y_ = 0;
  clear_has_y();
}
inline float CMsgVector2D::y() const {
  return y_;
}
inline void CMsgVector2D::set_y(float value) {
  set_has_y();
  y_ = value;
}

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

// CMsgQAngle

// optional float x = 1;
inline bool CMsgQAngle::has_x() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CMsgQAngle::set_has_x() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CMsgQAngle::clear_has_x() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CMsgQAngle::clear_x() {
  x_ = 0;
  clear_has_x();
}
inline float CMsgQAngle::x() const {
  return x_;
}
inline void CMsgQAngle::set_x(float value) {
  set_has_x();
  x_ = value;
}

// optional float y = 2;
inline bool CMsgQAngle::has_y() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CMsgQAngle::set_has_y() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CMsgQAngle::clear_has_y() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CMsgQAngle::clear_y() {
  y_ = 0;
  clear_has_y();
}
inline float CMsgQAngle::y() const {
  return y_;
}
inline void CMsgQAngle::set_y(float value) {
  set_has_y();
  y_ = value;
}

// optional float z = 3;
inline bool CMsgQAngle::has_z() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CMsgQAngle::set_has_z() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CMsgQAngle::clear_has_z() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CMsgQAngle::clear_z() {
  z_ = 0;
  clear_has_z();
}
inline float CMsgQAngle::z() const {
  return z_;
}
inline void CMsgQAngle::set_z(float value) {
  set_has_z();
  z_ = value;
}

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

// CMsg_CVars_CVar

// optional string name = 1;
inline bool CMsg_CVars_CVar::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CMsg_CVars_CVar::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CMsg_CVars_CVar::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CMsg_CVars_CVar::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& CMsg_CVars_CVar::name() const {
  return *name_;
}
inline void CMsg_CVars_CVar::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void CMsg_CVars_CVar::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void CMsg_CVars_CVar::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CMsg_CVars_CVar::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* CMsg_CVars_CVar::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string value = 2;
inline bool CMsg_CVars_CVar::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CMsg_CVars_CVar::set_has_value() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CMsg_CVars_CVar::clear_has_value() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CMsg_CVars_CVar::clear_value() {
  if (value_ != &::google::protobuf::internal::kEmptyString) {
    value_->clear();
  }
  clear_has_value();
}
inline const ::std::string& CMsg_CVars_CVar::value() const {
  return *value_;
}
inline void CMsg_CVars_CVar::set_value(const ::std::string& value) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(value);
}
inline void CMsg_CVars_CVar::set_value(const char* value) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(value);
}
inline void CMsg_CVars_CVar::set_value(const char* value, size_t size) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CMsg_CVars_CVar::mutable_value() {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  return value_;
}
inline ::std::string* CMsg_CVars_CVar::release_value() {
  clear_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = value_;
    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CMsg_CVars

// repeated .CMsg_CVars.CVar cvars = 1;
inline int CMsg_CVars::cvars_size() const {
  return cvars_.size();
}
inline void CMsg_CVars::clear_cvars() {
  cvars_.Clear();
}
inline const ::CMsg_CVars_CVar& CMsg_CVars::cvars(int index) const {
  return cvars_.Get(index);
}
inline ::CMsg_CVars_CVar* CMsg_CVars::mutable_cvars(int index) {
  return cvars_.Mutable(index);
}
inline ::CMsg_CVars_CVar* CMsg_CVars::add_cvars() {
  return cvars_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::CMsg_CVars_CVar >&
CMsg_CVars::cvars() const {
  return cvars_;
}
inline ::google::protobuf::RepeatedPtrField< ::CMsg_CVars_CVar >*
CMsg_CVars::mutable_cvars() {
  return &cvars_;
}

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

// CNETMsg_NOP

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

// CNETMsg_Disconnect

// optional string text = 1;
inline bool CNETMsg_Disconnect::has_text() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CNETMsg_Disconnect::set_has_text() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CNETMsg_Disconnect::clear_has_text() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CNETMsg_Disconnect::clear_text() {
  if (text_ != &::google::protobuf::internal::kEmptyString) {
    text_->clear();
  }
  clear_has_text();
}
inline const ::std::string& CNETMsg_Disconnect::text() const {
  return *text_;
}
inline void CNETMsg_Disconnect::set_text(const ::std::string& value) {
  set_has_text();
  if (text_ == &::google::protobuf::internal::kEmptyString) {
    text_ = new ::std::string;
  }
  text_->assign(value);
}
inline void CNETMsg_Disconnect::set_text(const char* value) {
  set_has_text();
  if (text_ == &::google::protobuf::internal::kEmptyString) {
    text_ = new ::std::string;
  }
  text_->assign(value);
}
inline void CNETMsg_Disconnect::set_text(const char* value, size_t size) {
  set_has_text();
  if (text_ == &::google::protobuf::internal::kEmptyString) {
    text_ = new ::std::string;
  }
  text_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CNETMsg_Disconnect::mutable_text() {
  set_has_text();
  if (text_ == &::google::protobuf::internal::kEmptyString) {
    text_ = new ::std::string;
  }
  return text_;
}
inline ::std::string* CNETMsg_Disconnect::release_text() {
  clear_has_text();
  if (text_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = text_;
    text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CNETMsg_File

// optional int32 transfer_id = 1;
inline bool CNETMsg_File::has_transfer_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CNETMsg_File::set_has_transfer_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CNETMsg_File::clear_has_transfer_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CNETMsg_File::clear_transfer_id() {
  transfer_id_ = 0;
  clear_has_transfer_id();
}
inline ::google::protobuf::int32 CNETMsg_File::transfer_id() const {
  return transfer_id_;
}
inline void CNETMsg_File::set_transfer_id(::google::protobuf::int32 value) {
  set_has_transfer_id();
  transfer_id_ = value;
}

// optional string file_name = 2;
inline bool CNETMsg_File::has_file_name() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CNETMsg_File::set_has_file_name() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CNETMsg_File::clear_has_file_name() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CNETMsg_File::clear_file_name() {
  if (file_name_ != &::google::protobuf::internal::kEmptyString) {
    file_name_->clear();
  }
  clear_has_file_name();
}
inline const ::std::string& CNETMsg_File::file_name() const {
  return *file_name_;
}
inline void CNETMsg_File::set_file_name(const ::std::string& value) {
  set_has_file_name();
  if (file_name_ == &::google::protobuf::internal::kEmptyString) {
    file_name_ = new ::std::string;
  }
  file_name_->assign(value);
}
inline void CNETMsg_File::set_file_name(const char* value) {
  set_has_file_name();
  if (file_name_ == &::google::protobuf::internal::kEmptyString) {
    file_name_ = new ::std::string;
  }
  file_name_->assign(value);
}
inline void CNETMsg_File::set_file_name(const char* value, size_t size) {
  set_has_file_name();
  if (file_name_ == &::google::protobuf::internal::kEmptyString) {
    file_name_ = new ::std::string;
  }
  file_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CNETMsg_File::mutable_file_name() {
  set_has_file_name();
  if (file_name_ == &::google::protobuf::internal::kEmptyString) {
    file_name_ = new ::std::string;
  }
  return file_name_;
}
inline ::std::string* CNETMsg_File::release_file_name() {
  clear_has_file_name();
  if (file_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = file_name_;
    file_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional bool is_replay_demo_file = 3;
inline bool CNETMsg_File::has_is_replay_demo_file() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CNETMsg_File::set_has_is_replay_demo_file() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CNETMsg_File::clear_has_is_replay_demo_file() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CNETMsg_File::clear_is_replay_demo_file() {
  is_replay_demo_file_ = false;
  clear_has_is_replay_demo_file();
}
inline bool CNETMsg_File::is_replay_demo_file() const {
  return is_replay_demo_file_;
}
inline void CNETMsg_File::set_is_replay_demo_file(bool value) {
  set_has_is_replay_demo_file();
  is_replay_demo_file_ = value;
}

// optional bool deny = 4;
inline bool CNETMsg_File::has_deny() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CNETMsg_File::set_has_deny() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CNETMsg_File::clear_has_deny() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CNETMsg_File::clear_deny() {
  deny_ = false;
  clear_has_deny();
}
inline bool CNETMsg_File::deny() const {
  return deny_;
}
inline void CNETMsg_File::set_deny(bool value) {
  set_has_deny();
  deny_ = value;
}

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

// CNETMsg_SplitScreenUser

// optional int32 slot = 1;
inline bool CNETMsg_SplitScreenUser::has_slot() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CNETMsg_SplitScreenUser::set_has_slot() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CNETMsg_SplitScreenUser::clear_has_slot() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CNETMsg_SplitScreenUser::clear_slot() {
  slot_ = 0;
  clear_has_slot();
}
inline ::google::protobuf::int32 CNETMsg_SplitScreenUser::slot() const {
  return slot_;
}
inline void CNETMsg_SplitScreenUser::set_slot(::google::protobuf::int32 value) {
  set_has_slot();
  slot_ = value;
}

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

// CNETMsg_Tick

// optional uint32 tick = 1;
inline bool CNETMsg_Tick::has_tick() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CNETMsg_Tick::set_has_tick() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CNETMsg_Tick::clear_has_tick() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CNETMsg_Tick::clear_tick() {
  tick_ = 0u;
  clear_has_tick();
}
inline ::google::protobuf::uint32 CNETMsg_Tick::tick() const {
  return tick_;
}
inline void CNETMsg_Tick::set_tick(::google::protobuf::uint32 value) {
  set_has_tick();
  tick_ = value;
}

// optional uint32 host_frametime = 2;
inline bool CNETMsg_Tick::has_host_frametime() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CNETMsg_Tick::set_has_host_frametime() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CNETMsg_Tick::clear_has_host_frametime() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CNETMsg_Tick::clear_host_frametime() {
  host_frametime_ = 0u;
  clear_has_host_frametime();
}
inline ::google::protobuf::uint32 CNETMsg_Tick::host_frametime() const {
  return host_frametime_;
}
inline void CNETMsg_Tick::set_host_frametime(::google::protobuf::uint32 value) {
  set_has_host_frametime();
  host_frametime_ = value;
}

// optional uint32 host_frametime_std_deviation = 3;
inline bool CNETMsg_Tick::has_host_frametime_std_deviation() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CNETMsg_Tick::set_has_host_frametime_std_deviation() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CNETMsg_Tick::clear_has_host_frametime_std_deviation() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CNETMsg_Tick::clear_host_frametime_std_deviation() {
  host_frametime_std_deviation_ = 0u;
  clear_has_host_frametime_std_deviation();
}
inline ::google::protobuf::uint32 CNETMsg_Tick::host_frametime_std_deviation() const {
  return host_frametime_std_deviation_;
}
inline void CNETMsg_Tick::set_host_frametime_std_deviation(::google::protobuf::uint32 value) {
  set_has_host_frametime_std_deviation();
  host_frametime_std_deviation_ = value;
}

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

// CNETMsg_StringCmd

// optional string command = 1;
inline bool CNETMsg_StringCmd::has_command() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CNETMsg_StringCmd::set_has_command() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CNETMsg_StringCmd::clear_has_command() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CNETMsg_StringCmd::clear_command() {
  if (command_ != &::google::protobuf::internal::kEmptyString) {
    command_->clear();
  }
  clear_has_command();
}
inline const ::std::string& CNETMsg_StringCmd::command() const {
  return *command_;
}
inline void CNETMsg_StringCmd::set_command(const ::std::string& value) {
  set_has_command();
  if (command_ == &::google::protobuf::internal::kEmptyString) {
    command_ = new ::std::string;
  }
  command_->assign(value);
}
inline void CNETMsg_StringCmd::set_command(const char* value) {
  set_has_command();
  if (command_ == &::google::protobuf::internal::kEmptyString) {
    command_ = new ::std::string;
  }
  command_->assign(value);
}
inline void CNETMsg_StringCmd::set_command(const char* value, size_t size) {
  set_has_command();
  if (command_ == &::google::protobuf::internal::kEmptyString) {
    command_ = new ::std::string;
  }
  command_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CNETMsg_StringCmd::mutable_command() {
  set_has_command();
  if (command_ == &::google::protobuf::internal::kEmptyString) {
    command_ = new ::std::string;
  }
  return command_;
}
inline ::std::string* CNETMsg_StringCmd::release_command() {
  clear_has_command();
  if (command_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = command_;
    command_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CNETMsg_SetConVar

// optional .CMsg_CVars convars = 1;
inline bool CNETMsg_SetConVar::has_convars() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CNETMsg_SetConVar::set_has_convars() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CNETMsg_SetConVar::clear_has_convars() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CNETMsg_SetConVar::clear_convars() {
  if (convars_ != NULL) convars_->::CMsg_CVars::Clear();
  clear_has_convars();
}
inline const ::CMsg_CVars& CNETMsg_SetConVar::convars() const {
  return convars_ != NULL ? *convars_ : *default_instance_->convars_;
}
inline ::CMsg_CVars* CNETMsg_SetConVar::mutable_convars() {
  set_has_convars();
  if (convars_ == NULL) convars_ = new ::CMsg_CVars;
  return convars_;
}
inline ::CMsg_CVars* CNETMsg_SetConVar::release_convars() {
  clear_has_convars();
  ::CMsg_CVars* temp = convars_;
  convars_ = NULL;
  return temp;
}

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

// CNETMsg_SignonState

// optional uint32 signon_state = 1;
inline bool CNETMsg_SignonState::has_signon_state() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CNETMsg_SignonState::set_has_signon_state() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CNETMsg_SignonState::clear_has_signon_state() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CNETMsg_SignonState::clear_signon_state() {
  signon_state_ = 0u;
  clear_has_signon_state();
}
inline ::google::protobuf::uint32 CNETMsg_SignonState::signon_state() const {
  return signon_state_;
}
inline void CNETMsg_SignonState::set_signon_state(::google::protobuf::uint32 value) {
  set_has_signon_state();
  signon_state_ = value;
}

// optional uint32 spawn_count = 2;
inline bool CNETMsg_SignonState::has_spawn_count() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CNETMsg_SignonState::set_has_spawn_count() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CNETMsg_SignonState::clear_has_spawn_count() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CNETMsg_SignonState::clear_spawn_count() {
  spawn_count_ = 0u;
  clear_has_spawn_count();
}
inline ::google::protobuf::uint32 CNETMsg_SignonState::spawn_count() const {
  return spawn_count_;
}
inline void CNETMsg_SignonState::set_spawn_count(::google::protobuf::uint32 value) {
  set_has_spawn_count();
  spawn_count_ = value;
}

// optional uint32 num_server_players = 3;
inline bool CNETMsg_SignonState::has_num_server_players() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CNETMsg_SignonState::set_has_num_server_players() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CNETMsg_SignonState::clear_has_num_server_players() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CNETMsg_SignonState::clear_num_server_players() {
  num_server_players_ = 0u;
  clear_has_num_server_players();
}
inline ::google::protobuf::uint32 CNETMsg_SignonState::num_server_players() const {
  return num_server_players_;
}
inline void CNETMsg_SignonState::set_num_server_players(::google::protobuf::uint32 value) {
  set_has_num_server_players();
  num_server_players_ = value;
}

// repeated string players_networkids = 4;
inline int CNETMsg_SignonState::players_networkids_size() const {
  return players_networkids_.size();
}
inline void CNETMsg_SignonState::clear_players_networkids() {
  players_networkids_.Clear();
}
inline const ::std::string& CNETMsg_SignonState::players_networkids(int index) const {
  return players_networkids_.Get(index);
}
inline ::std::string* CNETMsg_SignonState::mutable_players_networkids(int index) {
  return players_networkids_.Mutable(index);
}
inline void CNETMsg_SignonState::set_players_networkids(int index, const ::std::string& value) {
  players_networkids_.Mutable(index)->assign(value);
}
inline void CNETMsg_SignonState::set_players_networkids(int index, const char* value) {
  players_networkids_.Mutable(index)->assign(value);
}
inline void CNETMsg_SignonState::set_players_networkids(int index, const char* value, size_t size) {
  players_networkids_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CNETMsg_SignonState::add_players_networkids() {
  return players_networkids_.Add();
}
inline void CNETMsg_SignonState::add_players_networkids(const ::std::string& value) {
  players_networkids_.Add()->assign(value);
}
inline void CNETMsg_SignonState::add_players_networkids(const char* value) {
  players_networkids_.Add()->assign(value);
}
inline void CNETMsg_SignonState::add_players_networkids(const char* value, size_t size) {
  players_networkids_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
CNETMsg_SignonState::players_networkids() const {
  return players_networkids_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
CNETMsg_SignonState::mutable_players_networkids() {
  return &players_networkids_;
}

// optional string map_name = 5;
inline bool CNETMsg_SignonState::has_map_name() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CNETMsg_SignonState::set_has_map_name() {
  _has_bits_[0] |= 0x00000010u;
}
inline void CNETMsg_SignonState::clear_has_map_name() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void CNETMsg_SignonState::clear_map_name() {
  if (map_name_ != &::google::protobuf::internal::kEmptyString) {
    map_name_->clear();
  }
  clear_has_map_name();
}
inline const ::std::string& CNETMsg_SignonState::map_name() const {
  return *map_name_;
}
inline void CNETMsg_SignonState::set_map_name(const ::std::string& value) {
  set_has_map_name();
  if (map_name_ == &::google::protobuf::internal::kEmptyString) {
    map_name_ = new ::std::string;
  }
  map_name_->assign(value);
}
inline void CNETMsg_SignonState::set_map_name(const char* value) {
  set_has_map_name();
  if (map_name_ == &::google::protobuf::internal::kEmptyString) {
    map_name_ = new ::std::string;
  }
  map_name_->assign(value);
}
inline void CNETMsg_SignonState::set_map_name(const char* value, size_t size) {
  set_has_map_name();
  if (map_name_ == &::google::protobuf::internal::kEmptyString) {
    map_name_ = new ::std::string;
  }
  map_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CNETMsg_SignonState::mutable_map_name() {
  set_has_map_name();
  if (map_name_ == &::google::protobuf::internal::kEmptyString) {
    map_name_ = new ::std::string;
  }
  return map_name_;
}
inline ::std::string* CNETMsg_SignonState::release_map_name() {
  clear_has_map_name();
  if (map_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = map_name_;
    map_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CCLCMsg_ClientInfo

// optional fixed32 send_table_crc = 1;
inline bool CCLCMsg_ClientInfo::has_send_table_crc() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CCLCMsg_ClientInfo::set_has_send_table_crc() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CCLCMsg_ClientInfo::clear_has_send_table_crc() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CCLCMsg_ClientInfo::clear_send_table_crc() {
  send_table_crc_ = 0u;
  clear_has_send_table_crc();
}
inline ::google::protobuf::uint32 CCLCMsg_ClientInfo::send_table_crc() const {
  return send_table_crc_;
}
inline void CCLCMsg_ClientInfo::set_send_table_crc(::google::protobuf::uint32 value) {
  set_has_send_table_crc();
  send_table_crc_ = value;
}

// optional uint32 server_count = 2;
inline bool CCLCMsg_ClientInfo::has_server_count() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CCLCMsg_ClientInfo::set_has_server_count() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CCLCMsg_ClientInfo::clear_has_server_count() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CCLCMsg_ClientInfo::clear_server_count() {
  server_count_ = 0u;
  clear_has_server_count();
}
inline ::google::protobuf::uint32 CCLCMsg_ClientInfo::server_count() const {
  return server_count_;
}
inline void CCLCMsg_ClientInfo::set_server_count(::google::protobuf::uint32 value) {
  set_has_server_count();
  server_count_ = value;
}

// optional bool is_hltv = 3;
inline bool CCLCMsg_ClientInfo::has_is_hltv() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CCLCMsg_ClientInfo::set_has_is_hltv() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CCLCMsg_ClientInfo::clear_has_is_hltv() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CCLCMsg_ClientInfo::clear_is_hltv() {
  is_hltv_ = false;
  clear_has_is_hltv();
}
inline bool CCLCMsg_ClientInfo::is_hltv() const {
  return is_hltv_;
}
inline void CCLCMsg_ClientInfo::set_is_hltv(bool value) {
  set_has_is_hltv();
  is_hltv_ = value;
}

// optional bool is_replay = 4;
inline bool CCLCMsg_ClientInfo::has_is_replay() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CCLCMsg_ClientInfo::set_has_is_replay() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CCLCMsg_ClientInfo::clear_has_is_replay() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CCLCMsg_ClientInfo::clear_is_replay() {
  is_replay_ = false;
  clear_has_is_replay();
}
inline bool CCLCMsg_ClientInfo::is_replay() const {
  return is_replay_;
}
inline void CCLCMsg_ClientInfo::set_is_replay(bool value) {
  set_has_is_replay();
  is_replay_ = value;
}

// optional uint32 friends_id = 5;
inline bool CCLCMsg_ClientInfo::has_friends_id() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CCLCMsg_ClientInfo::set_has_friends_id() {
  _has_bits_[0] |= 0x00000010u;
}
inline void CCLCMsg_ClientInfo::clear_has_friends_id() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void CCLCMsg_ClientInfo::clear_friends_id() {
  friends_id_ = 0u;
  clear_has_friends_id();
}
inline ::google::protobuf::uint32 CCLCMsg_ClientInfo::friends_id() const {
  return friends_id_;
}
inline void CCLCMsg_ClientInfo::set_friends_id(::google::protobuf::uint32 value) {
  set_has_friends_id();
  friends_id_ = value;
}

// optional string friends_name = 6;
inline bool CCLCMsg_ClientInfo::has_friends_name() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void CCLCMsg_ClientInfo::set_has_friends_name() {
  _has_bits_[0] |= 0x00000020u;
}
inline void CCLCMsg_ClientInfo::clear_has_friends_name() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void CCLCMsg_ClientInfo::clear_friends_name() {
  if (friends_name_ != &::google::protobuf::internal::kEmptyString) {
    friends_name_->clear();
  }
  clear_has_friends_name();
}
inline const ::std::string& CCLCMsg_ClientInfo::friends_name() const {
  return *friends_name_;
}
inline void CCLCMsg_ClientInfo::set_friends_name(const ::std::string& value) {
  set_has_friends_name();
  if (friends_name_ == &::google::protobuf::internal::kEmptyString) {
    friends_name_ = new ::std::string;
  }
  friends_name_->assign(value);
}
inline void CCLCMsg_ClientInfo::set_friends_name(const char* value) {
  set_has_friends_name();
  if (friends_name_ == &::google::protobuf::internal::kEmptyString) {
    friends_name_ = new ::std::string;
  }
  friends_name_->assign(value);
}
inline void CCLCMsg_ClientInfo::set_friends_name(const char* value, size_t size) {
  set_has_friends_name();
  if (friends_name_ == &::google::protobuf::internal::kEmptyString) {
    friends_name_ = new ::std::string;
  }
  friends_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CCLCMsg_ClientInfo::mutable_friends_name() {
  set_has_friends_name();
  if (friends_name_ == &::google::protobuf::internal::kEmptyString) {
    friends_name_ = new ::std::string;
  }
  return friends_name_;
}
inline ::std::string* CCLCMsg_ClientInfo::release_friends_name() {
  clear_has_friends_name();
  if (friends_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = friends_name_;
    friends_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// repeated fixed32 custom_files = 7;
inline int CCLCMsg_ClientInfo::custom_files_size() const {
  return custom_files_.size();
}
inline void CCLCMsg_ClientInfo::clear_custom_files() {
  custom_files_.Clear();
}
inline ::google::protobuf::uint32 CCLCMsg_ClientInfo::custom_files(int index) const {
  return custom_files_.Get(index);
}
inline void CCLCMsg_ClientInfo::set_custom_files(int index, ::google::protobuf::uint32 value) {
  custom_files_.Set(index, value);
}
inline void CCLCMsg_ClientInfo::add_custom_files(::google::protobuf::uint32 value) {
  custom_files_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
CCLCMsg_ClientInfo::custom_files() const {
  return custom_files_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
CCLCMsg_ClientInfo::mutable_custom_files() {
  return &custom_files_;
}

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

// CCLCMsg_Move

// optional uint32 num_backup_commands = 1;
inline bool CCLCMsg_Move::has_num_backup_commands() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CCLCMsg_Move::set_has_num_backup_commands() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CCLCMsg_Move::clear_has_num_backup_commands() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CCLCMsg_Move::clear_num_backup_commands() {
  num_backup_commands_ = 0u;
  clear_has_num_backup_commands();
}
inline ::google::protobuf::uint32 CCLCMsg_Move::num_backup_commands() const {
  return num_backup_commands_;
}
inline void CCLCMsg_Move::set_num_backup_commands(::google::protobuf::uint32 value) {
  set_has_num_backup_commands();
  num_backup_commands_ = value;
}

// optional uint32 num_new_commands = 2;
inline bool CCLCMsg_Move::has_num_new_commands() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CCLCMsg_Move::set_has_num_new_commands() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CCLCMsg_Move::clear_has_num_new_commands() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CCLCMsg_Move::clear_num_new_commands() {
  num_new_commands_ = 0u;
  clear_has_num_new_commands();
}
inline ::google::protobuf::uint32 CCLCMsg_Move::num_new_commands() const {
  return num_new_commands_;
}
inline void CCLCMsg_Move::set_num_new_commands(::google::protobuf::uint32 value) {
  set_has_num_new_commands();
  num_new_commands_ = value;
}

// optional bytes data = 3;
inline bool CCLCMsg_Move::has_data() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CCLCMsg_Move::set_has_data() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CCLCMsg_Move::clear_has_data() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CCLCMsg_Move::clear_data() {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    data_->clear();
  }
  clear_has_data();
}
inline const ::std::string& CCLCMsg_Move::data() const {
  return *data_;
}
inline void CCLCMsg_Move::set_data(const ::std::string& value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void CCLCMsg_Move::set_data(const char* value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void CCLCMsg_Move::set_data(const void* value, size_t size) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CCLCMsg_Move::mutable_data() {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  return data_;
}
inline ::std::string* CCLCMsg_Move::release_data() {
  clear_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = data_;
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CCLCMsg_VoiceData

// optional bytes data = 1;
inline bool CCLCMsg_VoiceData::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CCLCMsg_VoiceData::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CCLCMsg_VoiceData::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CCLCMsg_VoiceData::clear_data() {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    data_->clear();
  }
  clear_has_data();
}
inline const ::std::string& CCLCMsg_VoiceData::data() const {
  return *data_;
}
inline void CCLCMsg_VoiceData::set_data(const ::std::string& value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void CCLCMsg_VoiceData::set_data(const char* value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void CCLCMsg_VoiceData::set_data(const void* value, size_t size) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CCLCMsg_VoiceData::mutable_data() {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  return data_;
}
inline ::std::string* CCLCMsg_VoiceData::release_data() {
  clear_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = data_;
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional fixed64 xuid = 2;
inline bool CCLCMsg_VoiceData::has_xuid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CCLCMsg_VoiceData::set_has_xuid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CCLCMsg_VoiceData::clear_has_xuid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CCLCMsg_VoiceData::clear_xuid() {
  xuid_ = GOOGLE_ULONGLONG(0);
  clear_has_xuid();
}
inline ::google::protobuf::uint64 CCLCMsg_VoiceData::xuid() const {
  return xuid_;
}
inline void CCLCMsg_VoiceData::set_xuid(::google::protobuf::uint64 value) {
  set_has_xuid();
  xuid_ = value;
}

// optional .VoiceDataFormat_t format = 3 [default = VOICEDATA_FORMAT_STEAM];
inline bool CCLCMsg_VoiceData::has_format() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CCLCMsg_VoiceData::set_has_format() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CCLCMsg_VoiceData::clear_has_format() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CCLCMsg_VoiceData::clear_format() {
  format_ = 0;
  clear_has_format();
}
inline VoiceDataFormat_t CCLCMsg_VoiceData::format() const {
  return static_cast< VoiceDataFormat_t >(format_);
}
inline void CCLCMsg_VoiceData::set_format(VoiceDataFormat_t value) {
  GOOGLE_DCHECK(VoiceDataFormat_t_IsValid(value));
  set_has_format();
  format_ = value;
}

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

// CCLCMsg_BaselineAck

// optional int32 baseline_tick = 1;
inline bool CCLCMsg_BaselineAck::has_baseline_tick() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CCLCMsg_BaselineAck::set_has_baseline_tick() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CCLCMsg_BaselineAck::clear_has_baseline_tick() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CCLCMsg_BaselineAck::clear_baseline_tick() {
  baseline_tick_ = 0;
  clear_has_baseline_tick();
}
inline ::google::protobuf::int32 CCLCMsg_BaselineAck::baseline_tick() const {
  return baseline_tick_;
}
inline void CCLCMsg_BaselineAck::set_baseline_tick(::google::protobuf::int32 value) {
  set_has_baseline_tick();
  baseline_tick_ = value;
}

// optional int32 baseline_nr = 2;
inline bool CCLCMsg_BaselineAck::has_baseline_nr() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CCLCMsg_BaselineAck::set_has_baseline_nr() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CCLCMsg_BaselineAck::clear_has_baseline_nr() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CCLCMsg_BaselineAck::clear_baseline_nr() {
  baseline_nr_ = 0;
  clear_has_baseline_nr();
}
inline ::google::protobuf::int32 CCLCMsg_BaselineAck::baseline_nr() const {
  return baseline_nr_;
}
inline void CCLCMsg_BaselineAck::set_baseline_nr(::google::protobuf::int32 value) {
  set_has_baseline_nr();
  baseline_nr_ = value;
}

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

// CCLCMsg_ListenEvents

// repeated fixed32 event_mask = 1;
inline int CCLCMsg_ListenEvents::event_mask_size() const {
  return event_mask_.size();
}
inline void CCLCMsg_ListenEvents::clear_event_mask() {
  event_mask_.Clear();
}
inline ::google::protobuf::uint32 CCLCMsg_ListenEvents::event_mask(int index) const {
  return event_mask_.Get(index);
}
inline void CCLCMsg_ListenEvents::set_event_mask(int index, ::google::protobuf::uint32 value) {
  event_mask_.Set(index, value);
}
inline void CCLCMsg_ListenEvents::add_event_mask(::google::protobuf::uint32 value) {
  event_mask_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
CCLCMsg_ListenEvents::event_mask() const {
  return event_mask_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
CCLCMsg_ListenEvents::mutable_event_mask() {
  return &event_mask_;
}

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

// CCLCMsg_RespondCvarValue

// optional int32 cookie = 1;
inline bool CCLCMsg_RespondCvarValue::has_cookie() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CCLCMsg_RespondCvarValue::set_has_cookie() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CCLCMsg_RespondCvarValue::clear_has_cookie() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CCLCMsg_RespondCvarValue::clear_cookie() {
  cookie_ = 0;
  clear_has_cookie();
}
inline ::google::protobuf::int32 CCLCMsg_RespondCvarValue::cookie() const {
  return cookie_;
}
inline void CCLCMsg_RespondCvarValue::set_cookie(::google::protobuf::int32 value) {
  set_has_cookie();
  cookie_ = value;
}

// optional int32 status_code = 2;
inline bool CCLCMsg_RespondCvarValue::has_status_code() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CCLCMsg_RespondCvarValue::set_has_status_code() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CCLCMsg_RespondCvarValue::clear_has_status_code() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CCLCMsg_RespondCvarValue::clear_status_code() {
  status_code_ = 0;
  clear_has_status_code();
}
inline ::google::protobuf::int32 CCLCMsg_RespondCvarValue::status_code() const {
  return status_code_;
}
inline void CCLCMsg_RespondCvarValue::set_status_code(::google::protobuf::int32 value) {
  set_has_status_code();
  status_code_ = value;
}

// optional string name = 3;
inline bool CCLCMsg_RespondCvarValue::has_name() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CCLCMsg_RespondCvarValue::set_has_name() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CCLCMsg_RespondCvarValue::clear_has_name() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CCLCMsg_RespondCvarValue::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& CCLCMsg_RespondCvarValue::name() const {
  return *name_;
}
inline void CCLCMsg_RespondCvarValue::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void CCLCMsg_RespondCvarValue::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void CCLCMsg_RespondCvarValue::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CCLCMsg_RespondCvarValue::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* CCLCMsg_RespondCvarValue::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string value = 4;
inline bool CCLCMsg_RespondCvarValue::has_value() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CCLCMsg_RespondCvarValue::set_has_value() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CCLCMsg_RespondCvarValue::clear_has_value() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CCLCMsg_RespondCvarValue::clear_value() {
  if (value_ != &::google::protobuf::internal::kEmptyString) {
    value_->clear();
  }
  clear_has_value();
}
inline const ::std::string& CCLCMsg_RespondCvarValue::value() const {
  return *value_;
}
inline void CCLCMsg_RespondCvarValue::set_value(const ::std::string& value) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(value);
}
inline void CCLCMsg_RespondCvarValue::set_value(const char* value) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(value);
}
inline void CCLCMsg_RespondCvarValue::set_value(const char* value, size_t size) {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  value_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CCLCMsg_RespondCvarValue::mutable_value() {
  set_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    value_ = new ::std::string;
  }
  return value_;
}
inline ::std::string* CCLCMsg_RespondCvarValue::release_value() {
  clear_has_value();
  if (value_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = value_;
    value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CCLCMsg_FileCRCCheck

// optional int32 code_path = 1;
inline bool CCLCMsg_FileCRCCheck::has_code_path() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CCLCMsg_FileCRCCheck::set_has_code_path() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CCLCMsg_FileCRCCheck::clear_has_code_path() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CCLCMsg_FileCRCCheck::clear_code_path() {
  code_path_ = 0;
  clear_has_code_path();
}
inline ::google::protobuf::int32 CCLCMsg_FileCRCCheck::code_path() const {
  return code_path_;
}
inline void CCLCMsg_FileCRCCheck::set_code_path(::google::protobuf::int32 value) {
  set_has_code_path();
  code_path_ = value;
}

// optional string path = 2;
inline bool CCLCMsg_FileCRCCheck::has_path() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CCLCMsg_FileCRCCheck::set_has_path() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CCLCMsg_FileCRCCheck::clear_has_path() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CCLCMsg_FileCRCCheck::clear_path() {
  if (path_ != &::google::protobuf::internal::kEmptyString) {
    path_->clear();
  }
  clear_has_path();
}
inline const ::std::string& CCLCMsg_FileCRCCheck::path() const {
  return *path_;
}
inline void CCLCMsg_FileCRCCheck::set_path(const ::std::string& value) {
  set_has_path();
  if (path_ == &::google::protobuf::internal::kEmptyString) {
    path_ = new ::std::string;
  }
  path_->assign(value);
}
inline void CCLCMsg_FileCRCCheck::set_path(const char* value) {
  set_has_path();
  if (path_ == &::google::protobuf::internal::kEmptyString) {
    path_ = new ::std::string;
  }
  path_->assign(value);
}
inline void CCLCMsg_FileCRCCheck::set_path(const char* value, size_t size) {
  set_has_path();
  if (path_ == &::google::protobuf::internal::kEmptyString) {
    path_ = new ::std::string;
  }
  path_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CCLCMsg_FileCRCCheck::mutable_path() {
  set_has_path();
  if (path_ == &::google::protobuf::internal::kEmptyString) {
    path_ = new ::std::string;
  }
  return path_;
}
inline ::std::string* CCLCMsg_FileCRCCheck::release_path() {
  clear_has_path();
  if (path_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = path_;
    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional int32 code_filename = 3;
inline bool CCLCMsg_FileCRCCheck::has_code_filename() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CCLCMsg_FileCRCCheck::set_has_code_filename() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CCLCMsg_FileCRCCheck::clear_has_code_filename() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CCLCMsg_FileCRCCheck::clear_code_filename() {
  code_filename_ = 0;
  clear_has_code_filename();
}
inline ::google::protobuf::int32 CCLCMsg_FileCRCCheck::code_filename() const {
  return code_filename_;
}
inline void CCLCMsg_FileCRCCheck::set_code_filename(::google::protobuf::int32 value) {
  set_has_code_filename();
  code_filename_ = value;
}

// optional string filename = 4;
inline bool CCLCMsg_FileCRCCheck::has_filename() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CCLCMsg_FileCRCCheck::set_has_filename() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CCLCMsg_FileCRCCheck::clear_has_filename() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CCLCMsg_FileCRCCheck::clear_filename() {
  if (filename_ != &::google::protobuf::internal::kEmptyString) {
    filename_->clear();
  }
  clear_has_filename();
}
inline const ::std::string& CCLCMsg_FileCRCCheck::filename() const {
  return *filename_;
}
inline void CCLCMsg_FileCRCCheck::set_filename(const ::std::string& value) {
  set_has_filename();
  if (filename_ == &::google::protobuf::internal::kEmptyString) {
    filename_ = new ::std::string;
  }
  filename_->assign(value);
}
inline void CCLCMsg_FileCRCCheck::set_filename(const char* value) {
  set_has_filename();
  if (filename_ == &::google::protobuf::internal::kEmptyString) {
    filename_ = new ::std::string;
  }
  filename_->assign(value);
}
inline void CCLCMsg_FileCRCCheck::set_filename(const char* value, size_t size) {
  set_has_filename();
  if (filename_ == &::google::protobuf::internal::kEmptyString) {
    filename_ = new ::std::string;
  }
  filename_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CCLCMsg_FileCRCCheck::mutable_filename() {
  set_has_filename();
  if (filename_ == &::google::protobuf::internal::kEmptyString) {
    filename_ = new ::std::string;
  }
  return filename_;
}
inline ::std::string* CCLCMsg_FileCRCCheck::release_filename() {
  clear_has_filename();
  if (filename_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = filename_;
    filename_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional fixed32 crc = 5;
inline bool CCLCMsg_FileCRCCheck::has_crc() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CCLCMsg_FileCRCCheck::set_has_crc() {
  _has_bits_[0] |= 0x00000010u;
}
inline void CCLCMsg_FileCRCCheck::clear_has_crc() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void CCLCMsg_FileCRCCheck::clear_crc() {
  crc_ = 0u;
  clear_has_crc();
}
inline ::google::protobuf::uint32 CCLCMsg_FileCRCCheck::crc() const {
  return crc_;
}
inline void CCLCMsg_FileCRCCheck::set_crc(::google::protobuf::uint32 value) {
  set_has_crc();
  crc_ = value;
}

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

// CCLCMsg_LoadingProgress

// optional int32 progress = 1;
inline bool CCLCMsg_LoadingProgress::has_progress() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CCLCMsg_LoadingProgress::set_has_progress() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CCLCMsg_LoadingProgress::clear_has_progress() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CCLCMsg_LoadingProgress::clear_progress() {
  progress_ = 0;
  clear_has_progress();
}
inline ::google::protobuf::int32 CCLCMsg_LoadingProgress::progress() const {
  return progress_;
}
inline void CCLCMsg_LoadingProgress::set_progress(::google::protobuf::int32 value) {
  set_has_progress();
  progress_ = value;
}

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

// CCLCMsg_SplitPlayerConnect

// optional .CMsg_CVars convars = 1;
inline bool CCLCMsg_SplitPlayerConnect::has_convars() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CCLCMsg_SplitPlayerConnect::set_has_convars() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CCLCMsg_SplitPlayerConnect::clear_has_convars() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CCLCMsg_SplitPlayerConnect::clear_convars() {
  if (convars_ != NULL) convars_->::CMsg_CVars::Clear();
  clear_has_convars();
}
inline const ::CMsg_CVars& CCLCMsg_SplitPlayerConnect::convars() const {
  return convars_ != NULL ? *convars_ : *default_instance_->convars_;
}
inline ::CMsg_CVars* CCLCMsg_SplitPlayerConnect::mutable_convars() {
  set_has_convars();
  if (convars_ == NULL) convars_ = new ::CMsg_CVars;
  return convars_;
}
inline ::CMsg_CVars* CCLCMsg_SplitPlayerConnect::release_convars() {
  clear_has_convars();
  ::CMsg_CVars* temp = convars_;
  convars_ = NULL;
  return temp;
}

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

// CCLCMsg_ClientMessage

// optional int32 msg_type = 1;
inline bool CCLCMsg_ClientMessage::has_msg_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CCLCMsg_ClientMessage::set_has_msg_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CCLCMsg_ClientMessage::clear_has_msg_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CCLCMsg_ClientMessage::clear_msg_type() {
  msg_type_ = 0;
  clear_has_msg_type();
}
inline ::google::protobuf::int32 CCLCMsg_ClientMessage::msg_type() const {
  return msg_type_;
}
inline void CCLCMsg_ClientMessage::set_msg_type(::google::protobuf::int32 value) {
  set_has_msg_type();
  msg_type_ = value;
}

// optional bytes data = 2;
inline bool CCLCMsg_ClientMessage::has_data() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CCLCMsg_ClientMessage::set_has_data() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CCLCMsg_ClientMessage::clear_has_data() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CCLCMsg_ClientMessage::clear_data() {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    data_->clear();
  }
  clear_has_data();
}
inline const ::std::string& CCLCMsg_ClientMessage::data() const {
  return *data_;
}
inline void CCLCMsg_ClientMessage::set_data(const ::std::string& value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void CCLCMsg_ClientMessage::set_data(const char* value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(value);
}
inline void CCLCMsg_ClientMessage::set_data(const void* value, size_t size) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CCLCMsg_ClientMessage::mutable_data() {
  set_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    data_ = new ::std::string;
  }
  return data_;
}
inline ::std::string* CCLCMsg_ClientMessage::release_data() {
  clear_has_data();
  if (data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = data_;
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CSVCMsg_ServerInfo

// optional int32 protocol = 1;
inline bool CSVCMsg_ServerInfo::has_protocol() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_protocol() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_ServerInfo::clear_has_protocol() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_ServerInfo::clear_protocol() {
  protocol_ = 0;
  clear_has_protocol();
}
inline ::google::protobuf::int32 CSVCMsg_ServerInfo::protocol() const {
  return protocol_;
}
inline void CSVCMsg_ServerInfo::set_protocol(::google::protobuf::int32 value) {
  set_has_protocol();
  protocol_ = value;
}

// optional int32 server_count = 2;
inline bool CSVCMsg_ServerInfo::has_server_count() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_server_count() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_ServerInfo::clear_has_server_count() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_ServerInfo::clear_server_count() {
  server_count_ = 0;
  clear_has_server_count();
}
inline ::google::protobuf::int32 CSVCMsg_ServerInfo::server_count() const {
  return server_count_;
}
inline void CSVCMsg_ServerInfo::set_server_count(::google::protobuf::int32 value) {
  set_has_server_count();
  server_count_ = value;
}

// optional bool is_dedicated = 3;
inline bool CSVCMsg_ServerInfo::has_is_dedicated() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_is_dedicated() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CSVCMsg_ServerInfo::clear_has_is_dedicated() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CSVCMsg_ServerInfo::clear_is_dedicated() {
  is_dedicated_ = false;
  clear_has_is_dedicated();
}
inline bool CSVCMsg_ServerInfo::is_dedicated() const {
  return is_dedicated_;
}
inline void CSVCMsg_ServerInfo::set_is_dedicated(bool value) {
  set_has_is_dedicated();
  is_dedicated_ = value;
}

// optional bool is_hltv = 4;
inline bool CSVCMsg_ServerInfo::has_is_hltv() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_is_hltv() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CSVCMsg_ServerInfo::clear_has_is_hltv() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CSVCMsg_ServerInfo::clear_is_hltv() {
  is_hltv_ = false;
  clear_has_is_hltv();
}
inline bool CSVCMsg_ServerInfo::is_hltv() const {
  return is_hltv_;
}
inline void CSVCMsg_ServerInfo::set_is_hltv(bool value) {
  set_has_is_hltv();
  is_hltv_ = value;
}

// optional bool is_replay = 5;
inline bool CSVCMsg_ServerInfo::has_is_replay() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_is_replay() {
  _has_bits_[0] |= 0x00000010u;
}
inline void CSVCMsg_ServerInfo::clear_has_is_replay() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void CSVCMsg_ServerInfo::clear_is_replay() {
  is_replay_ = false;
  clear_has_is_replay();
}
inline bool CSVCMsg_ServerInfo::is_replay() const {
  return is_replay_;
}
inline void CSVCMsg_ServerInfo::set_is_replay(bool value) {
  set_has_is_replay();
  is_replay_ = value;
}

// optional int32 c_os = 6;
inline bool CSVCMsg_ServerInfo::has_c_os() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_c_os() {
  _has_bits_[0] |= 0x00000020u;
}
inline void CSVCMsg_ServerInfo::clear_has_c_os() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void CSVCMsg_ServerInfo::clear_c_os() {
  c_os_ = 0;
  clear_has_c_os();
}
inline ::google::protobuf::int32 CSVCMsg_ServerInfo::c_os() const {
  return c_os_;
}
inline void CSVCMsg_ServerInfo::set_c_os(::google::protobuf::int32 value) {
  set_has_c_os();
  c_os_ = value;
}

// optional fixed32 map_crc = 7;
inline bool CSVCMsg_ServerInfo::has_map_crc() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_map_crc() {
  _has_bits_[0] |= 0x00000040u;
}
inline void CSVCMsg_ServerInfo::clear_has_map_crc() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void CSVCMsg_ServerInfo::clear_map_crc() {
  map_crc_ = 0u;
  clear_has_map_crc();
}
inline ::google::protobuf::uint32 CSVCMsg_ServerInfo::map_crc() const {
  return map_crc_;
}
inline void CSVCMsg_ServerInfo::set_map_crc(::google::protobuf::uint32 value) {
  set_has_map_crc();
  map_crc_ = value;
}

// optional fixed32 client_crc = 8;
inline bool CSVCMsg_ServerInfo::has_client_crc() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_client_crc() {
  _has_bits_[0] |= 0x00000080u;
}
inline void CSVCMsg_ServerInfo::clear_has_client_crc() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void CSVCMsg_ServerInfo::clear_client_crc() {
  client_crc_ = 0u;
  clear_has_client_crc();
}
inline ::google::protobuf::uint32 CSVCMsg_ServerInfo::client_crc() const {
  return client_crc_;
}
inline void CSVCMsg_ServerInfo::set_client_crc(::google::protobuf::uint32 value) {
  set_has_client_crc();
  client_crc_ = value;
}

// optional fixed32 string_table_crc = 9;
inline bool CSVCMsg_ServerInfo::has_string_table_crc() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_string_table_crc() {
  _has_bits_[0] |= 0x00000100u;
}
inline void CSVCMsg_ServerInfo::clear_has_string_table_crc() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void CSVCMsg_ServerInfo::clear_string_table_crc() {
  string_table_crc_ = 0u;
  clear_has_string_table_crc();
}
inline ::google::protobuf::uint32 CSVCMsg_ServerInfo::string_table_crc() const {
  return string_table_crc_;
}
inline void CSVCMsg_ServerInfo::set_string_table_crc(::google::protobuf::uint32 value) {
  set_has_string_table_crc();
  string_table_crc_ = value;
}

// optional int32 max_clients = 10;
inline bool CSVCMsg_ServerInfo::has_max_clients() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_max_clients() {
  _has_bits_[0] |= 0x00000200u;
}
inline void CSVCMsg_ServerInfo::clear_has_max_clients() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void CSVCMsg_ServerInfo::clear_max_clients() {
  max_clients_ = 0;
  clear_has_max_clients();
}
inline ::google::protobuf::int32 CSVCMsg_ServerInfo::max_clients() const {
  return max_clients_;
}
inline void CSVCMsg_ServerInfo::set_max_clients(::google::protobuf::int32 value) {
  set_has_max_clients();
  max_clients_ = value;
}

// optional int32 max_classes = 11;
inline bool CSVCMsg_ServerInfo::has_max_classes() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_max_classes() {
  _has_bits_[0] |= 0x00000400u;
}
inline void CSVCMsg_ServerInfo::clear_has_max_classes() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void CSVCMsg_ServerInfo::clear_max_classes() {
  max_classes_ = 0;
  clear_has_max_classes();
}
inline ::google::protobuf::int32 CSVCMsg_ServerInfo::max_classes() const {
  return max_classes_;
}
inline void CSVCMsg_ServerInfo::set_max_classes(::google::protobuf::int32 value) {
  set_has_max_classes();
  max_classes_ = value;
}

// optional int32 player_slot = 12;
inline bool CSVCMsg_ServerInfo::has_player_slot() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_player_slot() {
  _has_bits_[0] |= 0x00000800u;
}
inline void CSVCMsg_ServerInfo::clear_has_player_slot() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void CSVCMsg_ServerInfo::clear_player_slot() {
  player_slot_ = 0;
  clear_has_player_slot();
}
inline ::google::protobuf::int32 CSVCMsg_ServerInfo::player_slot() const {
  return player_slot_;
}
inline void CSVCMsg_ServerInfo::set_player_slot(::google::protobuf::int32 value) {
  set_has_player_slot();
  player_slot_ = value;
}

// optional float tick_interval = 13;
inline bool CSVCMsg_ServerInfo::has_tick_interval() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_tick_interval() {
  _has_bits_[0] |= 0x00001000u;
}
inline void CSVCMsg_ServerInfo::clear_has_tick_interval() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void CSVCMsg_ServerInfo::clear_tick_interval() {
  tick_interval_ = 0;
  clear_has_tick_interval();
}
inline float CSVCMsg_ServerInfo::tick_interval() const {
  return tick_interval_;
}
inline void CSVCMsg_ServerInfo::set_tick_interval(float value) {
  set_has_tick_interval();
  tick_interval_ = value;
}

// optional string game_dir = 14;
inline bool CSVCMsg_ServerInfo::has_game_dir() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_game_dir() {
  _has_bits_[0] |= 0x00002000u;
}
inline void CSVCMsg_ServerInfo::clear_has_game_dir() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void CSVCMsg_ServerInfo::clear_game_dir() {
  if (game_dir_ != &::google::protobuf::internal::kEmptyString) {
    game_dir_->clear();
  }
  clear_has_game_dir();
}
inline const ::std::string& CSVCMsg_ServerInfo::game_dir() const {
  return *game_dir_;
}
inline void CSVCMsg_ServerInfo::set_game_dir(const ::std::string& value) {
  set_has_game_dir();
  if (game_dir_ == &::google::protobuf::internal::kEmptyString) {
    game_dir_ = new ::std::string;
  }
  game_dir_->assign(value);
}
inline void CSVCMsg_ServerInfo::set_game_dir(const char* value) {
  set_has_game_dir();
  if (game_dir_ == &::google::protobuf::internal::kEmptyString) {
    game_dir_ = new ::std::string;
  }
  game_dir_->assign(value);
}
inline void CSVCMsg_ServerInfo::set_game_dir(const char* value, size_t size) {
  set_has_game_dir();
  if (game_dir_ == &::google::protobuf::internal::kEmptyString) {
    game_dir_ = new ::std::string;
  }
  game_dir_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_ServerInfo::mutable_game_dir() {
  set_has_game_dir();
  if (game_dir_ == &::google::protobuf::internal::kEmptyString) {
    game_dir_ = new ::std::string;
  }
  return game_dir_;
}
inline ::std::string* CSVCMsg_ServerInfo::release_game_dir() {
  clear_has_game_dir();
  if (game_dir_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = game_dir_;
    game_dir_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string map_name = 15;
inline bool CSVCMsg_ServerInfo::has_map_name() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_map_name() {
  _has_bits_[0] |= 0x00004000u;
}
inline void CSVCMsg_ServerInfo::clear_has_map_name() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void CSVCMsg_ServerInfo::clear_map_name() {
  if (map_name_ != &::google::protobuf::internal::kEmptyString) {
    map_name_->clear();
  }
  clear_has_map_name();
}
inline const ::std::string& CSVCMsg_ServerInfo::map_name() const {
  return *map_name_;
}
inline void CSVCMsg_ServerInfo::set_map_name(const ::std::string& value) {
  set_has_map_name();
  if (map_name_ == &::google::protobuf::internal::kEmptyString) {
    map_name_ = new ::std::string;
  }
  map_name_->assign(value);
}
inline void CSVCMsg_ServerInfo::set_map_name(const char* value) {
  set_has_map_name();
  if (map_name_ == &::google::protobuf::internal::kEmptyString) {
    map_name_ = new ::std::string;
  }
  map_name_->assign(value);
}
inline void CSVCMsg_ServerInfo::set_map_name(const char* value, size_t size) {
  set_has_map_name();
  if (map_name_ == &::google::protobuf::internal::kEmptyString) {
    map_name_ = new ::std::string;
  }
  map_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_ServerInfo::mutable_map_name() {
  set_has_map_name();
  if (map_name_ == &::google::protobuf::internal::kEmptyString) {
    map_name_ = new ::std::string;
  }
  return map_name_;
}
inline ::std::string* CSVCMsg_ServerInfo::release_map_name() {
  clear_has_map_name();
  if (map_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = map_name_;
    map_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string sky_name = 16;
inline bool CSVCMsg_ServerInfo::has_sky_name() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_sky_name() {
  _has_bits_[0] |= 0x00008000u;
}
inline void CSVCMsg_ServerInfo::clear_has_sky_name() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void CSVCMsg_ServerInfo::clear_sky_name() {
  if (sky_name_ != &::google::protobuf::internal::kEmptyString) {
    sky_name_->clear();
  }
  clear_has_sky_name();
}
inline const ::std::string& CSVCMsg_ServerInfo::sky_name() const {
  return *sky_name_;
}
inline void CSVCMsg_ServerInfo::set_sky_name(const ::std::string& value) {
  set_has_sky_name();
  if (sky_name_ == &::google::protobuf::internal::kEmptyString) {
    sky_name_ = new ::std::string;
  }
  sky_name_->assign(value);
}
inline void CSVCMsg_ServerInfo::set_sky_name(const char* value) {
  set_has_sky_name();
  if (sky_name_ == &::google::protobuf::internal::kEmptyString) {
    sky_name_ = new ::std::string;
  }
  sky_name_->assign(value);
}
inline void CSVCMsg_ServerInfo::set_sky_name(const char* value, size_t size) {
  set_has_sky_name();
  if (sky_name_ == &::google::protobuf::internal::kEmptyString) {
    sky_name_ = new ::std::string;
  }
  sky_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_ServerInfo::mutable_sky_name() {
  set_has_sky_name();
  if (sky_name_ == &::google::protobuf::internal::kEmptyString) {
    sky_name_ = new ::std::string;
  }
  return sky_name_;
}
inline ::std::string* CSVCMsg_ServerInfo::release_sky_name() {
  clear_has_sky_name();
  if (sky_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = sky_name_;
    sky_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string host_name = 17;
inline bool CSVCMsg_ServerInfo::has_host_name() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void CSVCMsg_ServerInfo::set_has_host_name() {
  _has_bits_[0] |= 0x00010000u;
}
inline void CSVCMsg_ServerInfo::clear_has_host_name() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void CSVCMsg_ServerInfo::clear_host_name() {
  if (host_name_ != &::google::protobuf::internal::kEmptyString) {
    host_name_->clear();
  }
  clear_has_host_name();
}
inline const ::std::string& CSVCMsg_ServerInfo::host_name() const {
  return *host_name_;
}
inline void CSVCMsg_ServerInfo::set_host_name(const ::std::string& value) {
  set_has_host_name();
  if (host_name_ == &::google::protobuf::internal::kEmptyString) {
    host_name_ = new ::std::string;
  }
  host_name_->assign(value);
}
inline void CSVCMsg_ServerInfo::set_host_name(const char* value) {
  set_has_host_name();
  if (host_name_ == &::google::protobuf::internal::kEmptyString) {
    host_name_ = new ::std::string;
  }
  host_name_->assign(value);
}
inline void CSVCMsg_ServerInfo::set_host_name(const char* value, size_t size) {
  set_has_host_name();
  if (host_name_ == &::google::protobuf::internal::kEmptyString) {
    host_name_ = new ::std::string;
  }
  host_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_ServerInfo::mutable_host_name() {
  set_has_host_name();
  if (host_name_ == &::google::protobuf::internal::kEmptyString) {
    host_name_ = new ::std::string;
  }
  return host_name_;
}
inline ::std::string* CSVCMsg_ServerInfo::release_host_name() {
  clear_has_host_name();
  if (host_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = host_name_;
    host_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CSVCMsg_ClassInfo_class_t

// optional int32 class_id = 1;
inline bool CSVCMsg_ClassInfo_class_t::has_class_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_ClassInfo_class_t::set_has_class_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_ClassInfo_class_t::clear_has_class_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_ClassInfo_class_t::clear_class_id() {
  class_id_ = 0;
  clear_has_class_id();
}
inline ::google::protobuf::int32 CSVCMsg_ClassInfo_class_t::class_id() const {
  return class_id_;
}
inline void CSVCMsg_ClassInfo_class_t::set_class_id(::google::protobuf::int32 value) {
  set_has_class_id();
  class_id_ = value;
}

// optional string data_table_name = 2;
inline bool CSVCMsg_ClassInfo_class_t::has_data_table_name() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_ClassInfo_class_t::set_has_data_table_name() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_ClassInfo_class_t::clear_has_data_table_name() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_ClassInfo_class_t::clear_data_table_name() {
  if (data_table_name_ != &::google::protobuf::internal::kEmptyString) {
    data_table_name_->clear();
  }
  clear_has_data_table_name();
}
inline const ::std::string& CSVCMsg_ClassInfo_class_t::data_table_name() const {
  return *data_table_name_;
}
inline void CSVCMsg_ClassInfo_class_t::set_data_table_name(const ::std::string& value) {
  set_has_data_table_name();
  if (data_table_name_ == &::google::protobuf::internal::kEmptyString) {
    data_table_name_ = new ::std::string;
  }
  data_table_name_->assign(value);
}
inline void CSVCMsg_ClassInfo_class_t::set_data_table_name(const char* value) {
  set_has_data_table_name();
  if (data_table_name_ == &::google::protobuf::internal::kEmptyString) {
    data_table_name_ = new ::std::string;
  }
  data_table_name_->assign(value);
}
inline void CSVCMsg_ClassInfo_class_t::set_data_table_name(const char* value, size_t size) {
  set_has_data_table_name();
  if (data_table_name_ == &::google::protobuf::internal::kEmptyString) {
    data_table_name_ = new ::std::string;
  }
  data_table_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_ClassInfo_class_t::mutable_data_table_name() {
  set_has_data_table_name();
  if (data_table_name_ == &::google::protobuf::internal::kEmptyString) {
    data_table_name_ = new ::std::string;
  }
  return data_table_name_;
}
inline ::std::string* CSVCMsg_ClassInfo_class_t::release_data_table_name() {
  clear_has_data_table_name();
  if (data_table_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = data_table_name_;
    data_table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string class_name = 3;
inline bool CSVCMsg_ClassInfo_class_t::has_class_name() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CSVCMsg_ClassInfo_class_t::set_has_class_name() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CSVCMsg_ClassInfo_class_t::clear_has_class_name() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CSVCMsg_ClassInfo_class_t::clear_class_name() {
  if (class_name_ != &::google::protobuf::internal::kEmptyString) {
    class_name_->clear();
  }
  clear_has_class_name();
}
inline const ::std::string& CSVCMsg_ClassInfo_class_t::class_name() const {
  return *class_name_;
}
inline void CSVCMsg_ClassInfo_class_t::set_class_name(const ::std::string& value) {
  set_has_class_name();
  if (class_name_ == &::google::protobuf::internal::kEmptyString) {
    class_name_ = new ::std::string;
  }
  class_name_->assign(value);
}
inline void CSVCMsg_ClassInfo_class_t::set_class_name(const char* value) {
  set_has_class_name();
  if (class_name_ == &::google::protobuf::internal::kEmptyString) {
    class_name_ = new ::std::string;
  }
  class_name_->assign(value);
}
inline void CSVCMsg_ClassInfo_class_t::set_class_name(const char* value, size_t size) {
  set_has_class_name();
  if (class_name_ == &::google::protobuf::internal::kEmptyString) {
    class_name_ = new ::std::string;
  }
  class_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_ClassInfo_class_t::mutable_class_name() {
  set_has_class_name();
  if (class_name_ == &::google::protobuf::internal::kEmptyString) {
    class_name_ = new ::std::string;
  }
  return class_name_;
}
inline ::std::string* CSVCMsg_ClassInfo_class_t::release_class_name() {
  clear_has_class_name();
  if (class_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = class_name_;
    class_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CSVCMsg_ClassInfo

// optional bool create_on_client = 1;
inline bool CSVCMsg_ClassInfo::has_create_on_client() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_ClassInfo::set_has_create_on_client() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_ClassInfo::clear_has_create_on_client() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_ClassInfo::clear_create_on_client() {
  create_on_client_ = false;
  clear_has_create_on_client();
}
inline bool CSVCMsg_ClassInfo::create_on_client() const {
  return create_on_client_;
}
inline void CSVCMsg_ClassInfo::set_create_on_client(bool value) {
  set_has_create_on_client();
  create_on_client_ = value;
}

// repeated .CSVCMsg_ClassInfo.class_t classes = 2;
inline int CSVCMsg_ClassInfo::classes_size() const {
  return classes_.size();
}
inline void CSVCMsg_ClassInfo::clear_classes() {
  classes_.Clear();
}
inline const ::CSVCMsg_ClassInfo_class_t& CSVCMsg_ClassInfo::classes(int index) const {
  return classes_.Get(index);
}
inline ::CSVCMsg_ClassInfo_class_t* CSVCMsg_ClassInfo::mutable_classes(int index) {
  return classes_.Mutable(index);
}
inline ::CSVCMsg_ClassInfo_class_t* CSVCMsg_ClassInfo::add_classes() {
  return classes_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsg_ClassInfo_class_t >&
CSVCMsg_ClassInfo::classes() const {
  return classes_;
}
inline ::google::protobuf::RepeatedPtrField< ::CSVCMsg_ClassInfo_class_t >*
CSVCMsg_ClassInfo::mutable_classes() {
  return &classes_;
}

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

// CSVCMsg_SetPause

// optional bool paused = 1;
inline bool CSVCMsg_SetPause::has_paused() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_SetPause::set_has_paused() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_SetPause::clear_has_paused() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_SetPause::clear_paused() {
  paused_ = false;
  clear_has_paused();
}
inline bool CSVCMsg_SetPause::paused() const {
  return paused_;
}
inline void CSVCMsg_SetPause::set_paused(bool value) {
  set_has_paused();
  paused_ = value;
}

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

// CSVCMsg_VoiceInit

// optional int32 quality = 1;
inline bool CSVCMsg_VoiceInit::has_quality() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_VoiceInit::set_has_quality() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_VoiceInit::clear_has_quality() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_VoiceInit::clear_quality() {
  quality_ = 0;
  clear_has_quality();
}
inline ::google::protobuf::int32 CSVCMsg_VoiceInit::quality() const {
  return quality_;
}
inline void CSVCMsg_VoiceInit::set_quality(::google::protobuf::int32 value) {
  set_has_quality();
  quality_ = value;
}

// optional string codec = 2;
inline bool CSVCMsg_VoiceInit::has_codec() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_VoiceInit::set_has_codec() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_VoiceInit::clear_has_codec() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_VoiceInit::clear_codec() {
  if (codec_ != &::google::protobuf::internal::kEmptyString) {
    codec_->clear();
  }
  clear_has_codec();
}
inline const ::std::string& CSVCMsg_VoiceInit::codec() const {
  return *codec_;
}
inline void CSVCMsg_VoiceInit::set_codec(const ::std::string& value) {
  set_has_codec();
  if (codec_ == &::google::protobuf::internal::kEmptyString) {
    codec_ = new ::std::string;
  }
  codec_->assign(value);
}
inline void CSVCMsg_VoiceInit::set_codec(const char* value) {
  set_has_codec();
  if (codec_ == &::google::protobuf::internal::kEmptyString) {
    codec_ = new ::std::string;
  }
  codec_->assign(value);
}
inline void CSVCMsg_VoiceInit::set_codec(const char* value, size_t size) {
  set_has_codec();
  if (codec_ == &::google::protobuf::internal::kEmptyString) {
    codec_ = new ::std::string;
  }
  codec_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_VoiceInit::mutable_codec() {
  set_has_codec();
  if (codec_ == &::google::protobuf::internal::kEmptyString) {
    codec_ = new ::std::string;
  }
  return codec_;
}
inline ::std::string* CSVCMsg_VoiceInit::release_codec() {
  clear_has_codec();
  if (codec_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = codec_;
    codec_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional int32 version = 3 [default = 0];
inline bool CSVCMsg_VoiceInit::has_version() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CSVCMsg_VoiceInit::set_has_version() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CSVCMsg_VoiceInit::clear_has_version() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CSVCMsg_VoiceInit::clear_version() {
  version_ = 0;
  clear_has_version();
}
inline ::google::protobuf::int32 CSVCMsg_VoiceInit::version() const {
  return version_;
}
inline void CSVCMsg_VoiceInit::set_version(::google::protobuf::int32 value) {
  set_has_version();
  version_ = value;
}

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

// CSVCMsg_Print

// optional string text = 1;
inline bool CSVCMsg_Print::has_text() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_Print::set_has_text() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_Print::clear_has_text() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_Print::clear_text() {
  if (text_ != &::google::protobuf::internal::kEmptyString) {
    text_->clear();
  }
  clear_has_text();
}
inline const ::std::string& CSVCMsg_Print::text() const {
  return *text_;
}
inline void CSVCMsg_Print::set_text(const ::std::string& value) {
  set_has_text();
  if (text_ == &::google::protobuf::internal::kEmptyString) {
    text_ = new ::std::string;
  }
  text_->assign(value);
}
inline void CSVCMsg_Print::set_text(const char* value) {
  set_has_text();
  if (text_ == &::google::protobuf::internal::kEmptyString) {
    text_ = new ::std::string;
  }
  text_->assign(value);
}
inline void CSVCMsg_Print::set_text(const char* value, size_t size) {
  set_has_text();
  if (text_ == &::google::protobuf::internal::kEmptyString) {
    text_ = new ::std::string;
  }
  text_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_Print::mutable_text() {
  set_has_text();
  if (text_ == &::google::protobuf::internal::kEmptyString) {
    text_ = new ::std::string;
  }
  return text_;
}
inline ::std::string* CSVCMsg_Print::release_text() {
  clear_has_text();
  if (text_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = text_;
    text_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CSVCMsg_Sounds_sounddata_t

// optional sint32 origin_x = 1;
inline bool CSVCMsg_Sounds_sounddata_t::has_origin_x() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_origin_x() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_origin_x() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_origin_x() {
  origin_x_ = 0;
  clear_has_origin_x();
}
inline ::google::protobuf::int32 CSVCMsg_Sounds_sounddata_t::origin_x() const {
  return origin_x_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_origin_x(::google::protobuf::int32 value) {
  set_has_origin_x();
  origin_x_ = value;
}

// optional sint32 origin_y = 2;
inline bool CSVCMsg_Sounds_sounddata_t::has_origin_y() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_origin_y() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_origin_y() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_origin_y() {
  origin_y_ = 0;
  clear_has_origin_y();
}
inline ::google::protobuf::int32 CSVCMsg_Sounds_sounddata_t::origin_y() const {
  return origin_y_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_origin_y(::google::protobuf::int32 value) {
  set_has_origin_y();
  origin_y_ = value;
}

// optional sint32 origin_z = 3;
inline bool CSVCMsg_Sounds_sounddata_t::has_origin_z() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_origin_z() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_origin_z() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_origin_z() {
  origin_z_ = 0;
  clear_has_origin_z();
}
inline ::google::protobuf::int32 CSVCMsg_Sounds_sounddata_t::origin_z() const {
  return origin_z_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_origin_z(::google::protobuf::int32 value) {
  set_has_origin_z();
  origin_z_ = value;
}

// optional uint32 volume = 4;
inline bool CSVCMsg_Sounds_sounddata_t::has_volume() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_volume() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_volume() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_volume() {
  volume_ = 0u;
  clear_has_volume();
}
inline ::google::protobuf::uint32 CSVCMsg_Sounds_sounddata_t::volume() const {
  return volume_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_volume(::google::protobuf::uint32 value) {
  set_has_volume();
  volume_ = value;
}

// optional float delay_value = 5;
inline bool CSVCMsg_Sounds_sounddata_t::has_delay_value() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_delay_value() {
  _has_bits_[0] |= 0x00000010u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_delay_value() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_delay_value() {
  delay_value_ = 0;
  clear_has_delay_value();
}
inline float CSVCMsg_Sounds_sounddata_t::delay_value() const {
  return delay_value_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_delay_value(float value) {
  set_has_delay_value();
  delay_value_ = value;
}

// optional int32 sequence_number = 6;
inline bool CSVCMsg_Sounds_sounddata_t::has_sequence_number() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_sequence_number() {
  _has_bits_[0] |= 0x00000020u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_sequence_number() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_sequence_number() {
  sequence_number_ = 0;
  clear_has_sequence_number();
}
inline ::google::protobuf::int32 CSVCMsg_Sounds_sounddata_t::sequence_number() const {
  return sequence_number_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_sequence_number(::google::protobuf::int32 value) {
  set_has_sequence_number();
  sequence_number_ = value;
}

// optional int32 entity_index = 7;
inline bool CSVCMsg_Sounds_sounddata_t::has_entity_index() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_entity_index() {
  _has_bits_[0] |= 0x00000040u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_entity_index() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_entity_index() {
  entity_index_ = 0;
  clear_has_entity_index();
}
inline ::google::protobuf::int32 CSVCMsg_Sounds_sounddata_t::entity_index() const {
  return entity_index_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_entity_index(::google::protobuf::int32 value) {
  set_has_entity_index();
  entity_index_ = value;
}

// optional int32 channel = 8;
inline bool CSVCMsg_Sounds_sounddata_t::has_channel() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_channel() {
  _has_bits_[0] |= 0x00000080u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_channel() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_channel() {
  channel_ = 0;
  clear_has_channel();
}
inline ::google::protobuf::int32 CSVCMsg_Sounds_sounddata_t::channel() const {
  return channel_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_channel(::google::protobuf::int32 value) {
  set_has_channel();
  channel_ = value;
}

// optional int32 pitch = 9;
inline bool CSVCMsg_Sounds_sounddata_t::has_pitch() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_pitch() {
  _has_bits_[0] |= 0x00000100u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_pitch() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_pitch() {
  pitch_ = 0;
  clear_has_pitch();
}
inline ::google::protobuf::int32 CSVCMsg_Sounds_sounddata_t::pitch() const {
  return pitch_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_pitch(::google::protobuf::int32 value) {
  set_has_pitch();
  pitch_ = value;
}

// optional int32 flags = 10;
inline bool CSVCMsg_Sounds_sounddata_t::has_flags() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_flags() {
  _has_bits_[0] |= 0x00000200u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_flags() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_flags() {
  flags_ = 0;
  clear_has_flags();
}
inline ::google::protobuf::int32 CSVCMsg_Sounds_sounddata_t::flags() const {
  return flags_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_flags(::google::protobuf::int32 value) {
  set_has_flags();
  flags_ = value;
}

// optional uint32 sound_num = 11;
inline bool CSVCMsg_Sounds_sounddata_t::has_sound_num() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_sound_num() {
  _has_bits_[0] |= 0x00000400u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_sound_num() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_sound_num() {
  sound_num_ = 0u;
  clear_has_sound_num();
}
inline ::google::protobuf::uint32 CSVCMsg_Sounds_sounddata_t::sound_num() const {
  return sound_num_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_sound_num(::google::protobuf::uint32 value) {
  set_has_sound_num();
  sound_num_ = value;
}

// optional fixed32 sound_num_handle = 12;
inline bool CSVCMsg_Sounds_sounddata_t::has_sound_num_handle() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_sound_num_handle() {
  _has_bits_[0] |= 0x00000800u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_sound_num_handle() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_sound_num_handle() {
  sound_num_handle_ = 0u;
  clear_has_sound_num_handle();
}
inline ::google::protobuf::uint32 CSVCMsg_Sounds_sounddata_t::sound_num_handle() const {
  return sound_num_handle_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_sound_num_handle(::google::protobuf::uint32 value) {
  set_has_sound_num_handle();
  sound_num_handle_ = value;
}

// optional int32 speaker_entity = 13;
inline bool CSVCMsg_Sounds_sounddata_t::has_speaker_entity() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_speaker_entity() {
  _has_bits_[0] |= 0x00001000u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_speaker_entity() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_speaker_entity() {
  speaker_entity_ = 0;
  clear_has_speaker_entity();
}
inline ::google::protobuf::int32 CSVCMsg_Sounds_sounddata_t::speaker_entity() const {
  return speaker_entity_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_speaker_entity(::google::protobuf::int32 value) {
  set_has_speaker_entity();
  speaker_entity_ = value;
}

// optional int32 random_seed = 14;
inline bool CSVCMsg_Sounds_sounddata_t::has_random_seed() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_random_seed() {
  _has_bits_[0] |= 0x00002000u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_random_seed() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_random_seed() {
  random_seed_ = 0;
  clear_has_random_seed();
}
inline ::google::protobuf::int32 CSVCMsg_Sounds_sounddata_t::random_seed() const {
  return random_seed_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_random_seed(::google::protobuf::int32 value) {
  set_has_random_seed();
  random_seed_ = value;
}

// optional int32 sound_level = 15;
inline bool CSVCMsg_Sounds_sounddata_t::has_sound_level() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_sound_level() {
  _has_bits_[0] |= 0x00004000u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_sound_level() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_sound_level() {
  sound_level_ = 0;
  clear_has_sound_level();
}
inline ::google::protobuf::int32 CSVCMsg_Sounds_sounddata_t::sound_level() const {
  return sound_level_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_sound_level(::google::protobuf::int32 value) {
  set_has_sound_level();
  sound_level_ = value;
}

// optional bool is_sentence = 16;
inline bool CSVCMsg_Sounds_sounddata_t::has_is_sentence() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_is_sentence() {
  _has_bits_[0] |= 0x00008000u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_is_sentence() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_is_sentence() {
  is_sentence_ = false;
  clear_has_is_sentence();
}
inline bool CSVCMsg_Sounds_sounddata_t::is_sentence() const {
  return is_sentence_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_is_sentence(bool value) {
  set_has_is_sentence();
  is_sentence_ = value;
}

// optional bool is_ambient = 17;
inline bool CSVCMsg_Sounds_sounddata_t::has_is_ambient() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void CSVCMsg_Sounds_sounddata_t::set_has_is_ambient() {
  _has_bits_[0] |= 0x00010000u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_has_is_ambient() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void CSVCMsg_Sounds_sounddata_t::clear_is_ambient() {
  is_ambient_ = false;
  clear_has_is_ambient();
}
inline bool CSVCMsg_Sounds_sounddata_t::is_ambient() const {
  return is_ambient_;
}
inline void CSVCMsg_Sounds_sounddata_t::set_is_ambient(bool value) {
  set_has_is_ambient();
  is_ambient_ = value;
}

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

// CSVCMsg_Sounds

// optional bool reliable_sound = 1;
inline bool CSVCMsg_Sounds::has_reliable_sound() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_Sounds::set_has_reliable_sound() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_Sounds::clear_has_reliable_sound() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_Sounds::clear_reliable_sound() {
  reliable_sound_ = false;
  clear_has_reliable_sound();
}
inline bool CSVCMsg_Sounds::reliable_sound() const {
  return reliable_sound_;
}
inline void CSVCMsg_Sounds::set_reliable_sound(bool value) {
  set_has_reliable_sound();
  reliable_sound_ = value;
}

// repeated .CSVCMsg_Sounds.sounddata_t sounds = 2;
inline int CSVCMsg_Sounds::sounds_size() const {
  return sounds_.size();
}
inline void CSVCMsg_Sounds::clear_sounds() {
  sounds_.Clear();
}
inline const ::CSVCMsg_Sounds_sounddata_t& CSVCMsg_Sounds::sounds(int index) const {
  return sounds_.Get(index);
}
inline ::CSVCMsg_Sounds_sounddata_t* CSVCMsg_Sounds::mutable_sounds(int index) {
  return sounds_.Mutable(index);
}
inline ::CSVCMsg_Sounds_sounddata_t* CSVCMsg_Sounds::add_sounds() {
  return sounds_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsg_Sounds_sounddata_t >&
CSVCMsg_Sounds::sounds() const {
  return sounds_;
}
inline ::google::protobuf::RepeatedPtrField< ::CSVCMsg_Sounds_sounddata_t >*
CSVCMsg_Sounds::mutable_sounds() {
  return &sounds_;
}

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

// CSVCMsg_Prefetch

// optional int32 sound_index = 1;
inline bool CSVCMsg_Prefetch::has_sound_index() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_Prefetch::set_has_sound_index() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_Prefetch::clear_has_sound_index() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_Prefetch::clear_sound_index() {
  sound_index_ = 0;
  clear_has_sound_index();
}
inline ::google::protobuf::int32 CSVCMsg_Prefetch::sound_index() const {
  return sound_index_;
}
inline void CSVCMsg_Prefetch::set_sound_index(::google::protobuf::int32 value) {
  set_has_sound_index();
  sound_index_ = value;
}

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

// CSVCMsg_SetView

// optional int32 entity_index = 1;
inline bool CSVCMsg_SetView::has_entity_index() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_SetView::set_has_entity_index() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_SetView::clear_has_entity_index() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_SetView::clear_entity_index() {
  entity_index_ = 0;
  clear_has_entity_index();
}
inline ::google::protobuf::int32 CSVCMsg_SetView::entity_index() const {
  return entity_index_;
}
inline void CSVCMsg_SetView::set_entity_index(::google::protobuf::int32 value) {
  set_has_entity_index();
  entity_index_ = value;
}

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

// CSVCMsg_FixAngle

// optional bool relative = 1;
inline bool CSVCMsg_FixAngle::has_relative() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_FixAngle::set_has_relative() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_FixAngle::clear_has_relative() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_FixAngle::clear_relative() {
  relative_ = false;
  clear_has_relative();
}
inline bool CSVCMsg_FixAngle::relative() const {
  return relative_;
}
inline void CSVCMsg_FixAngle::set_relative(bool value) {
  set_has_relative();
  relative_ = value;
}

// optional .CMsgQAngle angle = 2;
inline bool CSVCMsg_FixAngle::has_angle() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_FixAngle::set_has_angle() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_FixAngle::clear_has_angle() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_FixAngle::clear_angle() {
  if (angle_ != NULL) angle_->::CMsgQAngle::Clear();
  clear_has_angle();
}
inline const ::CMsgQAngle& CSVCMsg_FixAngle::angle() const {
  return angle_ != NULL ? *angle_ : *default_instance_->angle_;
}
inline ::CMsgQAngle* CSVCMsg_FixAngle::mutable_angle() {
  set_has_angle();
  if (angle_ == NULL) angle_ = new ::CMsgQAngle;
  return angle_;
}
inline ::CMsgQAngle* CSVCMsg_FixAngle::release_angle() {
  clear_has_angle();
  ::CMsgQAngle* temp = angle_;
  angle_ = NULL;
  return temp;
}

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

// CSVCMsg_CrosshairAngle

// optional .CMsgQAngle angle = 1;
inline bool CSVCMsg_CrosshairAngle::has_angle() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_CrosshairAngle::set_has_angle() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_CrosshairAngle::clear_has_angle() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_CrosshairAngle::clear_angle() {
  if (angle_ != NULL) angle_->::CMsgQAngle::Clear();
  clear_has_angle();
}
inline const ::CMsgQAngle& CSVCMsg_CrosshairAngle::angle() const {
  return angle_ != NULL ? *angle_ : *default_instance_->angle_;
}
inline ::CMsgQAngle* CSVCMsg_CrosshairAngle::mutable_angle() {
  set_has_angle();
  if (angle_ == NULL) angle_ = new ::CMsgQAngle;
  return angle_;
}
inline ::CMsgQAngle* CSVCMsg_CrosshairAngle::release_angle() {
  clear_has_angle();
  ::CMsgQAngle* temp = angle_;
  angle_ = NULL;
  return temp;
}

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

// CSVCMsg_BSPDecal

// optional .CMsgVector pos = 1;
inline bool CSVCMsg_BSPDecal::has_pos() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_BSPDecal::set_has_pos() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_BSPDecal::clear_has_pos() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_BSPDecal::clear_pos() {
  if (pos_ != NULL) pos_->::CMsgVector::Clear();
  clear_has_pos();
}
inline const ::CMsgVector& CSVCMsg_BSPDecal::pos() const {
  return pos_ != NULL ? *pos_ : *default_instance_->pos_;
}
inline ::CMsgVector* CSVCMsg_BSPDecal::mutable_pos() {
  set_has_pos();
  if (pos_ == NULL) pos_ = new ::CMsgVector;
  return pos_;
}
inline ::CMsgVector* CSVCMsg_BSPDecal::release_pos() {
  clear_has_pos();
  ::CMsgVector* temp = pos_;
  pos_ = NULL;
  return temp;
}

// optional int32 decal_texture_index = 2;
inline bool CSVCMsg_BSPDecal::has_decal_texture_index() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_BSPDecal::set_has_decal_texture_index() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_BSPDecal::clear_has_decal_texture_index() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_BSPDecal::clear_decal_texture_index() {
  decal_texture_index_ = 0;
  clear_has_decal_texture_index();
}
inline ::google::protobuf::int32 CSVCMsg_BSPDecal::decal_texture_index() const {
  return decal_texture_index_;
}
inline void CSVCMsg_BSPDecal::set_decal_texture_index(::google::protobuf::int32 value) {
  set_has_decal_texture_index();
  decal_texture_index_ = value;
}

// optional int32 entity_index = 3;
inline bool CSVCMsg_BSPDecal::has_entity_index() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CSVCMsg_BSPDecal::set_has_entity_index() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CSVCMsg_BSPDecal::clear_has_entity_index() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CSVCMsg_BSPDecal::clear_entity_index() {
  entity_index_ = 0;
  clear_has_entity_index();
}
inline ::google::protobuf::int32 CSVCMsg_BSPDecal::entity_index() const {
  return entity_index_;
}
inline void CSVCMsg_BSPDecal::set_entity_index(::google::protobuf::int32 value) {
  set_has_entity_index();
  entity_index_ = value;
}

// optional int32 model_index = 4;
inline bool CSVCMsg_BSPDecal::has_model_index() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CSVCMsg_BSPDecal::set_has_model_index() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CSVCMsg_BSPDecal::clear_has_model_index() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CSVCMsg_BSPDecal::clear_model_index() {
  model_index_ = 0;
  clear_has_model_index();
}
inline ::google::protobuf::int32 CSVCMsg_BSPDecal::model_index() const {
  return model_index_;
}
inline void CSVCMsg_BSPDecal::set_model_index(::google::protobuf::int32 value) {
  set_has_model_index();
  model_index_ = value;
}

// optional bool low_priority = 5;
inline bool CSVCMsg_BSPDecal::has_low_priority() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CSVCMsg_BSPDecal::set_has_low_priority() {
  _has_bits_[0] |= 0x00000010u;
}
inline void CSVCMsg_BSPDecal::clear_has_low_priority() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void CSVCMsg_BSPDecal::clear_low_priority() {
  low_priority_ = false;
  clear_has_low_priority();
}
inline bool CSVCMsg_BSPDecal::low_priority() const {
  return low_priority_;
}
inline void CSVCMsg_BSPDecal::set_low_priority(bool value) {
  set_has_low_priority();
  low_priority_ = value;
}

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

// CSVCMsg_SplitScreen

// optional .ESplitScreenMessageType type = 1 [default = MSG_SPLITSCREEN_ADDUSER];
inline bool CSVCMsg_SplitScreen::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_SplitScreen::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_SplitScreen::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_SplitScreen::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ESplitScreenMessageType CSVCMsg_SplitScreen::type() const {
  return static_cast< ESplitScreenMessageType >(type_);
}
inline void CSVCMsg_SplitScreen::set_type(ESplitScreenMessageType value) {
  GOOGLE_DCHECK(ESplitScreenMessageType_IsValid(value));
  set_has_type();
  type_ = value;
}

// optional int32 slot = 2;
inline bool CSVCMsg_SplitScreen::has_slot() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_SplitScreen::set_has_slot() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_SplitScreen::clear_has_slot() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_SplitScreen::clear_slot() {
  slot_ = 0;
  clear_has_slot();
}
inline ::google::protobuf::int32 CSVCMsg_SplitScreen::slot() const {
  return slot_;
}
inline void CSVCMsg_SplitScreen::set_slot(::google::protobuf::int32 value) {
  set_has_slot();
  slot_ = value;
}

// optional int32 player_index = 3;
inline bool CSVCMsg_SplitScreen::has_player_index() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CSVCMsg_SplitScreen::set_has_player_index() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CSVCMsg_SplitScreen::clear_has_player_index() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CSVCMsg_SplitScreen::clear_player_index() {
  player_index_ = 0;
  clear_has_player_index();
}
inline ::google::protobuf::int32 CSVCMsg_SplitScreen::player_index() const {
  return player_index_;
}
inline void CSVCMsg_SplitScreen::set_player_index(::google::protobuf::int32 value) {
  set_has_player_index();
  player_index_ = value;
}

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

// CSVCMsg_GetCvarValue

// optional int32 cookie = 1;
inline bool CSVCMsg_GetCvarValue::has_cookie() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_GetCvarValue::set_has_cookie() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_GetCvarValue::clear_has_cookie() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_GetCvarValue::clear_cookie() {
  cookie_ = 0;
  clear_has_cookie();
}
inline ::google::protobuf::int32 CSVCMsg_GetCvarValue::cookie() const {
  return cookie_;
}
inline void CSVCMsg_GetCvarValue::set_cookie(::google::protobuf::int32 value) {
  set_has_cookie();
  cookie_ = value;
}

// optional string cvar_name = 2;
inline bool CSVCMsg_GetCvarValue::has_cvar_name() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_GetCvarValue::set_has_cvar_name() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_GetCvarValue::clear_has_cvar_name() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_GetCvarValue::clear_cvar_name() {
  if (cvar_name_ != &::google::protobuf::internal::kEmptyString) {
    cvar_name_->clear();
  }
  clear_has_cvar_name();
}
inline const ::std::string& CSVCMsg_GetCvarValue::cvar_name() const {
  return *cvar_name_;
}
inline void CSVCMsg_GetCvarValue::set_cvar_name(const ::std::string& value) {
  set_has_cvar_name();
  if (cvar_name_ == &::google::protobuf::internal::kEmptyString) {
    cvar_name_ = new ::std::string;
  }
  cvar_name_->assign(value);
}
inline void CSVCMsg_GetCvarValue::set_cvar_name(const char* value) {
  set_has_cvar_name();
  if (cvar_name_ == &::google::protobuf::internal::kEmptyString) {
    cvar_name_ = new ::std::string;
  }
  cvar_name_->assign(value);
}
inline void CSVCMsg_GetCvarValue::set_cvar_name(const char* value, size_t size) {
  set_has_cvar_name();
  if (cvar_name_ == &::google::protobuf::internal::kEmptyString) {
    cvar_name_ = new ::std::string;
  }
  cvar_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_GetCvarValue::mutable_cvar_name() {
  set_has_cvar_name();
  if (cvar_name_ == &::google::protobuf::internal::kEmptyString) {
    cvar_name_ = new ::std::string;
  }
  return cvar_name_;
}
inline ::std::string* CSVCMsg_GetCvarValue::release_cvar_name() {
  clear_has_cvar_name();
  if (cvar_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = cvar_name_;
    cvar_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CSVCMsg_Menu

// optional int32 dialog_type = 1;
inline bool CSVCMsg_Menu::has_dialog_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_Menu::set_has_dialog_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_Menu::clear_has_dialog_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_Menu::clear_dialog_type() {
  dialog_type_ = 0;
  clear_has_dialog_type();
}
inline ::google::protobuf::int32 CSVCMsg_Menu::dialog_type() const {
  return dialog_type_;
}
inline void CSVCMsg_Menu::set_dialog_type(::google::protobuf::int32 value) {
  set_has_dialog_type();
  dialog_type_ = value;
}

// optional bytes menu_key_values = 2;
inline bool CSVCMsg_Menu::has_menu_key_values() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_Menu::set_has_menu_key_values() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_Menu::clear_has_menu_key_values() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_Menu::clear_menu_key_values() {
  if (menu_key_values_ != &::google::protobuf::internal::kEmptyString) {
    menu_key_values_->clear();
  }
  clear_has_menu_key_values();
}
inline const ::std::string& CSVCMsg_Menu::menu_key_values() const {
  return *menu_key_values_;
}
inline void CSVCMsg_Menu::set_menu_key_values(const ::std::string& value) {
  set_has_menu_key_values();
  if (menu_key_values_ == &::google::protobuf::internal::kEmptyString) {
    menu_key_values_ = new ::std::string;
  }
  menu_key_values_->assign(value);
}
inline void CSVCMsg_Menu::set_menu_key_values(const char* value) {
  set_has_menu_key_values();
  if (menu_key_values_ == &::google::protobuf::internal::kEmptyString) {
    menu_key_values_ = new ::std::string;
  }
  menu_key_values_->assign(value);
}
inline void CSVCMsg_Menu::set_menu_key_values(const void* value, size_t size) {
  set_has_menu_key_values();
  if (menu_key_values_ == &::google::protobuf::internal::kEmptyString) {
    menu_key_values_ = new ::std::string;
  }
  menu_key_values_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_Menu::mutable_menu_key_values() {
  set_has_menu_key_values();
  if (menu_key_values_ == &::google::protobuf::internal::kEmptyString) {
    menu_key_values_ = new ::std::string;
  }
  return menu_key_values_;
}
inline ::std::string* CSVCMsg_Menu::release_menu_key_values() {
  clear_has_menu_key_values();
  if (menu_key_values_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = menu_key_values_;
    menu_key_values_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CSVCMsg_SendTable_sendprop_t

// optional int32 type = 1;
inline bool CSVCMsg_SendTable_sendprop_t::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_SendTable_sendprop_t::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::google::protobuf::int32 CSVCMsg_SendTable_sendprop_t::type() const {
  return type_;
}
inline void CSVCMsg_SendTable_sendprop_t::set_type(::google::protobuf::int32 value) {
  set_has_type();
  type_ = value;
}

// optional string var_name = 2;
inline bool CSVCMsg_SendTable_sendprop_t::has_var_name() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_SendTable_sendprop_t::set_has_var_name() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_has_var_name() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_var_name() {
  if (var_name_ != &::google::protobuf::internal::kEmptyString) {
    var_name_->clear();
  }
  clear_has_var_name();
}
inline const ::std::string& CSVCMsg_SendTable_sendprop_t::var_name() const {
  return *var_name_;
}
inline void CSVCMsg_SendTable_sendprop_t::set_var_name(const ::std::string& value) {
  set_has_var_name();
  if (var_name_ == &::google::protobuf::internal::kEmptyString) {
    var_name_ = new ::std::string;
  }
  var_name_->assign(value);
}
inline void CSVCMsg_SendTable_sendprop_t::set_var_name(const char* value) {
  set_has_var_name();
  if (var_name_ == &::google::protobuf::internal::kEmptyString) {
    var_name_ = new ::std::string;
  }
  var_name_->assign(value);
}
inline void CSVCMsg_SendTable_sendprop_t::set_var_name(const char* value, size_t size) {
  set_has_var_name();
  if (var_name_ == &::google::protobuf::internal::kEmptyString) {
    var_name_ = new ::std::string;
  }
  var_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_SendTable_sendprop_t::mutable_var_name() {
  set_has_var_name();
  if (var_name_ == &::google::protobuf::internal::kEmptyString) {
    var_name_ = new ::std::string;
  }
  return var_name_;
}
inline ::std::string* CSVCMsg_SendTable_sendprop_t::release_var_name() {
  clear_has_var_name();
  if (var_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = var_name_;
    var_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional int32 flags = 3;
inline bool CSVCMsg_SendTable_sendprop_t::has_flags() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CSVCMsg_SendTable_sendprop_t::set_has_flags() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_has_flags() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_flags() {
  flags_ = 0;
  clear_has_flags();
}
inline ::google::protobuf::int32 CSVCMsg_SendTable_sendprop_t::flags() const {
  return flags_;
}
inline void CSVCMsg_SendTable_sendprop_t::set_flags(::google::protobuf::int32 value) {
  set_has_flags();
  flags_ = value;
}

// optional int32 priority = 4;
inline bool CSVCMsg_SendTable_sendprop_t::has_priority() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CSVCMsg_SendTable_sendprop_t::set_has_priority() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_has_priority() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_priority() {
  priority_ = 0;
  clear_has_priority();
}
inline ::google::protobuf::int32 CSVCMsg_SendTable_sendprop_t::priority() const {
  return priority_;
}
inline void CSVCMsg_SendTable_sendprop_t::set_priority(::google::protobuf::int32 value) {
  set_has_priority();
  priority_ = value;
}

// optional string dt_name = 5;
inline bool CSVCMsg_SendTable_sendprop_t::has_dt_name() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CSVCMsg_SendTable_sendprop_t::set_has_dt_name() {
  _has_bits_[0] |= 0x00000010u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_has_dt_name() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_dt_name() {
  if (dt_name_ != &::google::protobuf::internal::kEmptyString) {
    dt_name_->clear();
  }
  clear_has_dt_name();
}
inline const ::std::string& CSVCMsg_SendTable_sendprop_t::dt_name() const {
  return *dt_name_;
}
inline void CSVCMsg_SendTable_sendprop_t::set_dt_name(const ::std::string& value) {
  set_has_dt_name();
  if (dt_name_ == &::google::protobuf::internal::kEmptyString) {
    dt_name_ = new ::std::string;
  }
  dt_name_->assign(value);
}
inline void CSVCMsg_SendTable_sendprop_t::set_dt_name(const char* value) {
  set_has_dt_name();
  if (dt_name_ == &::google::protobuf::internal::kEmptyString) {
    dt_name_ = new ::std::string;
  }
  dt_name_->assign(value);
}
inline void CSVCMsg_SendTable_sendprop_t::set_dt_name(const char* value, size_t size) {
  set_has_dt_name();
  if (dt_name_ == &::google::protobuf::internal::kEmptyString) {
    dt_name_ = new ::std::string;
  }
  dt_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_SendTable_sendprop_t::mutable_dt_name() {
  set_has_dt_name();
  if (dt_name_ == &::google::protobuf::internal::kEmptyString) {
    dt_name_ = new ::std::string;
  }
  return dt_name_;
}
inline ::std::string* CSVCMsg_SendTable_sendprop_t::release_dt_name() {
  clear_has_dt_name();
  if (dt_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = dt_name_;
    dt_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional int32 num_elements = 6;
inline bool CSVCMsg_SendTable_sendprop_t::has_num_elements() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void CSVCMsg_SendTable_sendprop_t::set_has_num_elements() {
  _has_bits_[0] |= 0x00000020u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_has_num_elements() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_num_elements() {
  num_elements_ = 0;
  clear_has_num_elements();
}
inline ::google::protobuf::int32 CSVCMsg_SendTable_sendprop_t::num_elements() const {
  return num_elements_;
}
inline void CSVCMsg_SendTable_sendprop_t::set_num_elements(::google::protobuf::int32 value) {
  set_has_num_elements();
  num_elements_ = value;
}

// optional float low_value = 7;
inline bool CSVCMsg_SendTable_sendprop_t::has_low_value() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void CSVCMsg_SendTable_sendprop_t::set_has_low_value() {
  _has_bits_[0] |= 0x00000040u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_has_low_value() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_low_value() {
  low_value_ = 0;
  clear_has_low_value();
}
inline float CSVCMsg_SendTable_sendprop_t::low_value() const {
  return low_value_;
}
inline void CSVCMsg_SendTable_sendprop_t::set_low_value(float value) {
  set_has_low_value();
  low_value_ = value;
}

// optional float high_value = 8;
inline bool CSVCMsg_SendTable_sendprop_t::has_high_value() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void CSVCMsg_SendTable_sendprop_t::set_has_high_value() {
  _has_bits_[0] |= 0x00000080u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_has_high_value() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_high_value() {
  high_value_ = 0;
  clear_has_high_value();
}
inline float CSVCMsg_SendTable_sendprop_t::high_value() const {
  return high_value_;
}
inline void CSVCMsg_SendTable_sendprop_t::set_high_value(float value) {
  set_has_high_value();
  high_value_ = value;
}

// optional int32 num_bits = 9;
inline bool CSVCMsg_SendTable_sendprop_t::has_num_bits() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void CSVCMsg_SendTable_sendprop_t::set_has_num_bits() {
  _has_bits_[0] |= 0x00000100u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_has_num_bits() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void CSVCMsg_SendTable_sendprop_t::clear_num_bits() {
  num_bits_ = 0;
  clear_has_num_bits();
}
inline ::google::protobuf::int32 CSVCMsg_SendTable_sendprop_t::num_bits() const {
  return num_bits_;
}
inline void CSVCMsg_SendTable_sendprop_t::set_num_bits(::google::protobuf::int32 value) {
  set_has_num_bits();
  num_bits_ = value;
}

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

// CSVCMsg_SendTable

// optional bool is_end = 1;
inline bool CSVCMsg_SendTable::has_is_end() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_SendTable::set_has_is_end() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_SendTable::clear_has_is_end() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_SendTable::clear_is_end() {
  is_end_ = false;
  clear_has_is_end();
}
inline bool CSVCMsg_SendTable::is_end() const {
  return is_end_;
}
inline void CSVCMsg_SendTable::set_is_end(bool value) {
  set_has_is_end();
  is_end_ = value;
}

// optional string net_table_name = 2;
inline bool CSVCMsg_SendTable::has_net_table_name() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_SendTable::set_has_net_table_name() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_SendTable::clear_has_net_table_name() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_SendTable::clear_net_table_name() {
  if (net_table_name_ != &::google::protobuf::internal::kEmptyString) {
    net_table_name_->clear();
  }
  clear_has_net_table_name();
}
inline const ::std::string& CSVCMsg_SendTable::net_table_name() const {
  return *net_table_name_;
}
inline void CSVCMsg_SendTable::set_net_table_name(const ::std::string& value) {
  set_has_net_table_name();
  if (net_table_name_ == &::google::protobuf::internal::kEmptyString) {
    net_table_name_ = new ::std::string;
  }
  net_table_name_->assign(value);
}
inline void CSVCMsg_SendTable::set_net_table_name(const char* value) {
  set_has_net_table_name();
  if (net_table_name_ == &::google::protobuf::internal::kEmptyString) {
    net_table_name_ = new ::std::string;
  }
  net_table_name_->assign(value);
}
inline void CSVCMsg_SendTable::set_net_table_name(const char* value, size_t size) {
  set_has_net_table_name();
  if (net_table_name_ == &::google::protobuf::internal::kEmptyString) {
    net_table_name_ = new ::std::string;
  }
  net_table_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_SendTable::mutable_net_table_name() {
  set_has_net_table_name();
  if (net_table_name_ == &::google::protobuf::internal::kEmptyString) {
    net_table_name_ = new ::std::string;
  }
  return net_table_name_;
}
inline ::std::string* CSVCMsg_SendTable::release_net_table_name() {
  clear_has_net_table_name();
  if (net_table_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = net_table_name_;
    net_table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional bool needs_decoder = 3;
inline bool CSVCMsg_SendTable::has_needs_decoder() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CSVCMsg_SendTable::set_has_needs_decoder() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CSVCMsg_SendTable::clear_has_needs_decoder() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CSVCMsg_SendTable::clear_needs_decoder() {
  needs_decoder_ = false;
  clear_has_needs_decoder();
}
inline bool CSVCMsg_SendTable::needs_decoder() const {
  return needs_decoder_;
}
inline void CSVCMsg_SendTable::set_needs_decoder(bool value) {
  set_has_needs_decoder();
  needs_decoder_ = value;
}

// repeated .CSVCMsg_SendTable.sendprop_t props = 4;
inline int CSVCMsg_SendTable::props_size() const {
  return props_.size();
}
inline void CSVCMsg_SendTable::clear_props() {
  props_.Clear();
}
inline const ::CSVCMsg_SendTable_sendprop_t& CSVCMsg_SendTable::props(int index) const {
  return props_.Get(index);
}
inline ::CSVCMsg_SendTable_sendprop_t* CSVCMsg_SendTable::mutable_props(int index) {
  return props_.Mutable(index);
}
inline ::CSVCMsg_SendTable_sendprop_t* CSVCMsg_SendTable::add_props() {
  return props_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsg_SendTable_sendprop_t >&
CSVCMsg_SendTable::props() const {
  return props_;
}
inline ::google::protobuf::RepeatedPtrField< ::CSVCMsg_SendTable_sendprop_t >*
CSVCMsg_SendTable::mutable_props() {
  return &props_;
}

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

// CSVCMsg_GameEvent_key_t

// optional int32 type = 1;
inline bool CSVCMsg_GameEvent_key_t::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_GameEvent_key_t::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_GameEvent_key_t::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_GameEvent_key_t::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::google::protobuf::int32 CSVCMsg_GameEvent_key_t::type() const {
  return type_;
}
inline void CSVCMsg_GameEvent_key_t::set_type(::google::protobuf::int32 value) {
  set_has_type();
  type_ = value;
}

// optional string val_string = 2;
inline bool CSVCMsg_GameEvent_key_t::has_val_string() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_GameEvent_key_t::set_has_val_string() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_GameEvent_key_t::clear_has_val_string() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_GameEvent_key_t::clear_val_string() {
  if (val_string_ != &::google::protobuf::internal::kEmptyString) {
    val_string_->clear();
  }
  clear_has_val_string();
}
inline const ::std::string& CSVCMsg_GameEvent_key_t::val_string() const {
  return *val_string_;
}
inline void CSVCMsg_GameEvent_key_t::set_val_string(const ::std::string& value) {
  set_has_val_string();
  if (val_string_ == &::google::protobuf::internal::kEmptyString) {
    val_string_ = new ::std::string;
  }
  val_string_->assign(value);
}
inline void CSVCMsg_GameEvent_key_t::set_val_string(const char* value) {
  set_has_val_string();
  if (val_string_ == &::google::protobuf::internal::kEmptyString) {
    val_string_ = new ::std::string;
  }
  val_string_->assign(value);
}
inline void CSVCMsg_GameEvent_key_t::set_val_string(const char* value, size_t size) {
  set_has_val_string();
  if (val_string_ == &::google::protobuf::internal::kEmptyString) {
    val_string_ = new ::std::string;
  }
  val_string_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_GameEvent_key_t::mutable_val_string() {
  set_has_val_string();
  if (val_string_ == &::google::protobuf::internal::kEmptyString) {
    val_string_ = new ::std::string;
  }
  return val_string_;
}
inline ::std::string* CSVCMsg_GameEvent_key_t::release_val_string() {
  clear_has_val_string();
  if (val_string_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = val_string_;
    val_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional float val_float = 3;
inline bool CSVCMsg_GameEvent_key_t::has_val_float() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CSVCMsg_GameEvent_key_t::set_has_val_float() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CSVCMsg_GameEvent_key_t::clear_has_val_float() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CSVCMsg_GameEvent_key_t::clear_val_float() {
  val_float_ = 0;
  clear_has_val_float();
}
inline float CSVCMsg_GameEvent_key_t::val_float() const {
  return val_float_;
}
inline void CSVCMsg_GameEvent_key_t::set_val_float(float value) {
  set_has_val_float();
  val_float_ = value;
}

// optional int32 val_long = 4;
inline bool CSVCMsg_GameEvent_key_t::has_val_long() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CSVCMsg_GameEvent_key_t::set_has_val_long() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CSVCMsg_GameEvent_key_t::clear_has_val_long() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CSVCMsg_GameEvent_key_t::clear_val_long() {
  val_long_ = 0;
  clear_has_val_long();
}
inline ::google::protobuf::int32 CSVCMsg_GameEvent_key_t::val_long() const {
  return val_long_;
}
inline void CSVCMsg_GameEvent_key_t::set_val_long(::google::protobuf::int32 value) {
  set_has_val_long();
  val_long_ = value;
}

// optional int32 val_short = 5;
inline bool CSVCMsg_GameEvent_key_t::has_val_short() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CSVCMsg_GameEvent_key_t::set_has_val_short() {
  _has_bits_[0] |= 0x00000010u;
}
inline void CSVCMsg_GameEvent_key_t::clear_has_val_short() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void CSVCMsg_GameEvent_key_t::clear_val_short() {
  val_short_ = 0;
  clear_has_val_short();
}
inline ::google::protobuf::int32 CSVCMsg_GameEvent_key_t::val_short() const {
  return val_short_;
}
inline void CSVCMsg_GameEvent_key_t::set_val_short(::google::protobuf::int32 value) {
  set_has_val_short();
  val_short_ = value;
}

// optional int32 val_byte = 6;
inline bool CSVCMsg_GameEvent_key_t::has_val_byte() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void CSVCMsg_GameEvent_key_t::set_has_val_byte() {
  _has_bits_[0] |= 0x00000020u;
}
inline void CSVCMsg_GameEvent_key_t::clear_has_val_byte() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void CSVCMsg_GameEvent_key_t::clear_val_byte() {
  val_byte_ = 0;
  clear_has_val_byte();
}
inline ::google::protobuf::int32 CSVCMsg_GameEvent_key_t::val_byte() const {
  return val_byte_;
}
inline void CSVCMsg_GameEvent_key_t::set_val_byte(::google::protobuf::int32 value) {
  set_has_val_byte();
  val_byte_ = value;
}

// optional bool val_bool = 7;
inline bool CSVCMsg_GameEvent_key_t::has_val_bool() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void CSVCMsg_GameEvent_key_t::set_has_val_bool() {
  _has_bits_[0] |= 0x00000040u;
}
inline void CSVCMsg_GameEvent_key_t::clear_has_val_bool() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void CSVCMsg_GameEvent_key_t::clear_val_bool() {
  val_bool_ = false;
  clear_has_val_bool();
}
inline bool CSVCMsg_GameEvent_key_t::val_bool() const {
  return val_bool_;
}
inline void CSVCMsg_GameEvent_key_t::set_val_bool(bool value) {
  set_has_val_bool();
  val_bool_ = value;
}

// optional uint64 val_uint64 = 8;
inline bool CSVCMsg_GameEvent_key_t::has_val_uint64() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void CSVCMsg_GameEvent_key_t::set_has_val_uint64() {
  _has_bits_[0] |= 0x00000080u;
}
inline void CSVCMsg_GameEvent_key_t::clear_has_val_uint64() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void CSVCMsg_GameEvent_key_t::clear_val_uint64() {
  val_uint64_ = GOOGLE_ULONGLONG(0);
  clear_has_val_uint64();
}
inline ::google::protobuf::uint64 CSVCMsg_GameEvent_key_t::val_uint64() const {
  return val_uint64_;
}
inline void CSVCMsg_GameEvent_key_t::set_val_uint64(::google::protobuf::uint64 value) {
  set_has_val_uint64();
  val_uint64_ = value;
}

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

// CSVCMsg_GameEvent

// optional string event_name = 1;
inline bool CSVCMsg_GameEvent::has_event_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_GameEvent::set_has_event_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_GameEvent::clear_has_event_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_GameEvent::clear_event_name() {
  if (event_name_ != &::google::protobuf::internal::kEmptyString) {
    event_name_->clear();
  }
  clear_has_event_name();
}
inline const ::std::string& CSVCMsg_GameEvent::event_name() const {
  return *event_name_;
}
inline void CSVCMsg_GameEvent::set_event_name(const ::std::string& value) {
  set_has_event_name();
  if (event_name_ == &::google::protobuf::internal::kEmptyString) {
    event_name_ = new ::std::string;
  }
  event_name_->assign(value);
}
inline void CSVCMsg_GameEvent::set_event_name(const char* value) {
  set_has_event_name();
  if (event_name_ == &::google::protobuf::internal::kEmptyString) {
    event_name_ = new ::std::string;
  }
  event_name_->assign(value);
}
inline void CSVCMsg_GameEvent::set_event_name(const char* value, size_t size) {
  set_has_event_name();
  if (event_name_ == &::google::protobuf::internal::kEmptyString) {
    event_name_ = new ::std::string;
  }
  event_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_GameEvent::mutable_event_name() {
  set_has_event_name();
  if (event_name_ == &::google::protobuf::internal::kEmptyString) {
    event_name_ = new ::std::string;
  }
  return event_name_;
}
inline ::std::string* CSVCMsg_GameEvent::release_event_name() {
  clear_has_event_name();
  if (event_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = event_name_;
    event_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional int32 eventid = 2;
inline bool CSVCMsg_GameEvent::has_eventid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_GameEvent::set_has_eventid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_GameEvent::clear_has_eventid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_GameEvent::clear_eventid() {
  eventid_ = 0;
  clear_has_eventid();
}
inline ::google::protobuf::int32 CSVCMsg_GameEvent::eventid() const {
  return eventid_;
}
inline void CSVCMsg_GameEvent::set_eventid(::google::protobuf::int32 value) {
  set_has_eventid();
  eventid_ = value;
}

// repeated .CSVCMsg_GameEvent.key_t keys = 3;
inline int CSVCMsg_GameEvent::keys_size() const {
  return keys_.size();
}
inline void CSVCMsg_GameEvent::clear_keys() {
  keys_.Clear();
}
inline const ::CSVCMsg_GameEvent_key_t& CSVCMsg_GameEvent::keys(int index) const {
  return keys_.Get(index);
}
inline ::CSVCMsg_GameEvent_key_t* CSVCMsg_GameEvent::mutable_keys(int index) {
  return keys_.Mutable(index);
}
inline ::CSVCMsg_GameEvent_key_t* CSVCMsg_GameEvent::add_keys() {
  return keys_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsg_GameEvent_key_t >&
CSVCMsg_GameEvent::keys() const {
  return keys_;
}
inline ::google::protobuf::RepeatedPtrField< ::CSVCMsg_GameEvent_key_t >*
CSVCMsg_GameEvent::mutable_keys() {
  return &keys_;
}

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

// CSVCMsg_GameEventList_key_t

// optional int32 type = 1;
inline bool CSVCMsg_GameEventList_key_t::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_GameEventList_key_t::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_GameEventList_key_t::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_GameEventList_key_t::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::google::protobuf::int32 CSVCMsg_GameEventList_key_t::type() const {
  return type_;
}
inline void CSVCMsg_GameEventList_key_t::set_type(::google::protobuf::int32 value) {
  set_has_type();
  type_ = value;
}

// optional string name = 2;
inline bool CSVCMsg_GameEventList_key_t::has_name() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_GameEventList_key_t::set_has_name() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_GameEventList_key_t::clear_has_name() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_GameEventList_key_t::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& CSVCMsg_GameEventList_key_t::name() const {
  return *name_;
}
inline void CSVCMsg_GameEventList_key_t::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void CSVCMsg_GameEventList_key_t::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void CSVCMsg_GameEventList_key_t::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_GameEventList_key_t::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* CSVCMsg_GameEventList_key_t::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CSVCMsg_GameEventList_descriptor_t

// optional int32 eventid = 1;
inline bool CSVCMsg_GameEventList_descriptor_t::has_eventid() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_GameEventList_descriptor_t::set_has_eventid() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_GameEventList_descriptor_t::clear_has_eventid() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_GameEventList_descriptor_t::clear_eventid() {
  eventid_ = 0;
  clear_has_eventid();
}
inline ::google::protobuf::int32 CSVCMsg_GameEventList_descriptor_t::eventid() const {
  return eventid_;
}
inline void CSVCMsg_GameEventList_descriptor_t::set_eventid(::google::protobuf::int32 value) {
  set_has_eventid();
  eventid_ = value;
}

// optional string name = 2;
inline bool CSVCMsg_GameEventList_descriptor_t::has_name() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_GameEventList_descriptor_t::set_has_name() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_GameEventList_descriptor_t::clear_has_name() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_GameEventList_descriptor_t::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& CSVCMsg_GameEventList_descriptor_t::name() const {
  return *name_;
}
inline void CSVCMsg_GameEventList_descriptor_t::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void CSVCMsg_GameEventList_descriptor_t::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void CSVCMsg_GameEventList_descriptor_t::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_GameEventList_descriptor_t::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* CSVCMsg_GameEventList_descriptor_t::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// repeated .CSVCMsg_GameEventList.key_t keys = 3;
inline int CSVCMsg_GameEventList_descriptor_t::keys_size() const {
  return keys_.size();
}
inline void CSVCMsg_GameEventList_descriptor_t::clear_keys() {
  keys_.Clear();
}
inline const ::CSVCMsg_GameEventList_key_t& CSVCMsg_GameEventList_descriptor_t::keys(int index) const {
  return keys_.Get(index);
}
inline ::CSVCMsg_GameEventList_key_t* CSVCMsg_GameEventList_descriptor_t::mutable_keys(int index) {
  return keys_.Mutable(index);
}
inline ::CSVCMsg_GameEventList_key_t* CSVCMsg_GameEventList_descriptor_t::add_keys() {
  return keys_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsg_GameEventList_key_t >&
CSVCMsg_GameEventList_descriptor_t::keys() const {
  return keys_;
}
inline ::google::protobuf::RepeatedPtrField< ::CSVCMsg_GameEventList_key_t >*
CSVCMsg_GameEventList_descriptor_t::mutable_keys() {
  return &keys_;
}

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

// CSVCMsg_GameEventList

// repeated .CSVCMsg_GameEventList.descriptor_t descriptors = 1;
inline int CSVCMsg_GameEventList::descriptors_size() const {
  return descriptors_.size();
}
inline void CSVCMsg_GameEventList::clear_descriptors() {
  descriptors_.Clear();
}
inline const ::CSVCMsg_GameEventList_descriptor_t& CSVCMsg_GameEventList::descriptors(int index) const {
  return descriptors_.Get(index);
}
inline ::CSVCMsg_GameEventList_descriptor_t* CSVCMsg_GameEventList::mutable_descriptors(int index) {
  return descriptors_.Mutable(index);
}
inline ::CSVCMsg_GameEventList_descriptor_t* CSVCMsg_GameEventList::add_descriptors() {
  return descriptors_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsg_GameEventList_descriptor_t >&
CSVCMsg_GameEventList::descriptors() const {
  return descriptors_;
}
inline ::google::protobuf::RepeatedPtrField< ::CSVCMsg_GameEventList_descriptor_t >*
CSVCMsg_GameEventList::mutable_descriptors() {
  return &descriptors_;
}

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

// CSVCMsg_PacketEntities

// optional int32 max_entries = 1;
inline bool CSVCMsg_PacketEntities::has_max_entries() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_PacketEntities::set_has_max_entries() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_PacketEntities::clear_has_max_entries() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_PacketEntities::clear_max_entries() {
  max_entries_ = 0;
  clear_has_max_entries();
}
inline ::google::protobuf::int32 CSVCMsg_PacketEntities::max_entries() const {
  return max_entries_;
}
inline void CSVCMsg_PacketEntities::set_max_entries(::google::protobuf::int32 value) {
  set_has_max_entries();
  max_entries_ = value;
}

// optional int32 updated_entries = 2;
inline bool CSVCMsg_PacketEntities::has_updated_entries() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_PacketEntities::set_has_updated_entries() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_PacketEntities::clear_has_updated_entries() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_PacketEntities::clear_updated_entries() {
  updated_entries_ = 0;
  clear_has_updated_entries();
}
inline ::google::protobuf::int32 CSVCMsg_PacketEntities::updated_entries() const {
  return updated_entries_;
}
inline void CSVCMsg_PacketEntities::set_updated_entries(::google::protobuf::int32 value) {
  set_has_updated_entries();
  updated_entries_ = value;
}

// optional bool is_delta = 3;
inline bool CSVCMsg_PacketEntities::has_is_delta() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CSVCMsg_PacketEntities::set_has_is_delta() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CSVCMsg_PacketEntities::clear_has_is_delta() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CSVCMsg_PacketEntities::clear_is_delta() {
  is_delta_ = false;
  clear_has_is_delta();
}
inline bool CSVCMsg_PacketEntities::is_delta() const {
  return is_delta_;
}
inline void CSVCMsg_PacketEntities::set_is_delta(bool value) {
  set_has_is_delta();
  is_delta_ = value;
}

// optional bool update_baseline = 4;
inline bool CSVCMsg_PacketEntities::has_update_baseline() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CSVCMsg_PacketEntities::set_has_update_baseline() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CSVCMsg_PacketEntities::clear_has_update_baseline() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CSVCMsg_PacketEntities::clear_update_baseline() {
  update_baseline_ = false;
  clear_has_update_baseline();
}
inline bool CSVCMsg_PacketEntities::update_baseline() const {
  return update_baseline_;
}
inline void CSVCMsg_PacketEntities::set_update_baseline(bool value) {
  set_has_update_baseline();
  update_baseline_ = value;
}

// optional int32 baseline = 5;
inline bool CSVCMsg_PacketEntities::has_baseline() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CSVCMsg_PacketEntities::set_has_baseline() {
  _has_bits_[0] |= 0x00000010u;
}
inline void CSVCMsg_PacketEntities::clear_has_baseline() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void CSVCMsg_PacketEntities::clear_baseline() {
  baseline_ = 0;
  clear_has_baseline();
}
inline ::google::protobuf::int32 CSVCMsg_PacketEntities::baseline() const {
  return baseline_;
}
inline void CSVCMsg_PacketEntities::set_baseline(::google::protobuf::int32 value) {
  set_has_baseline();
  baseline_ = value;
}

// optional int32 delta_from = 6;
inline bool CSVCMsg_PacketEntities::has_delta_from() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void CSVCMsg_PacketEntities::set_has_delta_from() {
  _has_bits_[0] |= 0x00000020u;
}
inline void CSVCMsg_PacketEntities::clear_has_delta_from() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void CSVCMsg_PacketEntities::clear_delta_from() {
  delta_from_ = 0;
  clear_has_delta_from();
}
inline ::google::protobuf::int32 CSVCMsg_PacketEntities::delta_from() const {
  return delta_from_;
}
inline void CSVCMsg_PacketEntities::set_delta_from(::google::protobuf::int32 value) {
  set_has_delta_from();
  delta_from_ = value;
}

// optional bytes entity_data = 7;
inline bool CSVCMsg_PacketEntities::has_entity_data() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void CSVCMsg_PacketEntities::set_has_entity_data() {
  _has_bits_[0] |= 0x00000040u;
}
inline void CSVCMsg_PacketEntities::clear_has_entity_data() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void CSVCMsg_PacketEntities::clear_entity_data() {
  if (entity_data_ != &::google::protobuf::internal::kEmptyString) {
    entity_data_->clear();
  }
  clear_has_entity_data();
}
inline const ::std::string& CSVCMsg_PacketEntities::entity_data() const {
  return *entity_data_;
}
inline void CSVCMsg_PacketEntities::set_entity_data(const ::std::string& value) {
  set_has_entity_data();
  if (entity_data_ == &::google::protobuf::internal::kEmptyString) {
    entity_data_ = new ::std::string;
  }
  entity_data_->assign(value);
}
inline void CSVCMsg_PacketEntities::set_entity_data(const char* value) {
  set_has_entity_data();
  if (entity_data_ == &::google::protobuf::internal::kEmptyString) {
    entity_data_ = new ::std::string;
  }
  entity_data_->assign(value);
}
inline void CSVCMsg_PacketEntities::set_entity_data(const void* value, size_t size) {
  set_has_entity_data();
  if (entity_data_ == &::google::protobuf::internal::kEmptyString) {
    entity_data_ = new ::std::string;
  }
  entity_data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_PacketEntities::mutable_entity_data() {
  set_has_entity_data();
  if (entity_data_ == &::google::protobuf::internal::kEmptyString) {
    entity_data_ = new ::std::string;
  }
  return entity_data_;
}
inline ::std::string* CSVCMsg_PacketEntities::release_entity_data() {
  clear_has_entity_data();
  if (entity_data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = entity_data_;
    entity_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CSVCMsg_TempEntities

// optional bool reliable = 1;
inline bool CSVCMsg_TempEntities::has_reliable() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_TempEntities::set_has_reliable() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_TempEntities::clear_has_reliable() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_TempEntities::clear_reliable() {
  reliable_ = false;
  clear_has_reliable();
}
inline bool CSVCMsg_TempEntities::reliable() const {
  return reliable_;
}
inline void CSVCMsg_TempEntities::set_reliable(bool value) {
  set_has_reliable();
  reliable_ = value;
}

// optional int32 num_entries = 2;
inline bool CSVCMsg_TempEntities::has_num_entries() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_TempEntities::set_has_num_entries() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_TempEntities::clear_has_num_entries() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_TempEntities::clear_num_entries() {
  num_entries_ = 0;
  clear_has_num_entries();
}
inline ::google::protobuf::int32 CSVCMsg_TempEntities::num_entries() const {
  return num_entries_;
}
inline void CSVCMsg_TempEntities::set_num_entries(::google::protobuf::int32 value) {
  set_has_num_entries();
  num_entries_ = value;
}

// optional bytes entity_data = 3;
inline bool CSVCMsg_TempEntities::has_entity_data() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CSVCMsg_TempEntities::set_has_entity_data() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CSVCMsg_TempEntities::clear_has_entity_data() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CSVCMsg_TempEntities::clear_entity_data() {
  if (entity_data_ != &::google::protobuf::internal::kEmptyString) {
    entity_data_->clear();
  }
  clear_has_entity_data();
}
inline const ::std::string& CSVCMsg_TempEntities::entity_data() const {
  return *entity_data_;
}
inline void CSVCMsg_TempEntities::set_entity_data(const ::std::string& value) {
  set_has_entity_data();
  if (entity_data_ == &::google::protobuf::internal::kEmptyString) {
    entity_data_ = new ::std::string;
  }
  entity_data_->assign(value);
}
inline void CSVCMsg_TempEntities::set_entity_data(const char* value) {
  set_has_entity_data();
  if (entity_data_ == &::google::protobuf::internal::kEmptyString) {
    entity_data_ = new ::std::string;
  }
  entity_data_->assign(value);
}
inline void CSVCMsg_TempEntities::set_entity_data(const void* value, size_t size) {
  set_has_entity_data();
  if (entity_data_ == &::google::protobuf::internal::kEmptyString) {
    entity_data_ = new ::std::string;
  }
  entity_data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_TempEntities::mutable_entity_data() {
  set_has_entity_data();
  if (entity_data_ == &::google::protobuf::internal::kEmptyString) {
    entity_data_ = new ::std::string;
  }
  return entity_data_;
}
inline ::std::string* CSVCMsg_TempEntities::release_entity_data() {
  clear_has_entity_data();
  if (entity_data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = entity_data_;
    entity_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CSVCMsg_CreateStringTable

// optional string name = 1;
inline bool CSVCMsg_CreateStringTable::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_CreateStringTable::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_CreateStringTable::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_CreateStringTable::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& CSVCMsg_CreateStringTable::name() const {
  return *name_;
}
inline void CSVCMsg_CreateStringTable::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void CSVCMsg_CreateStringTable::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void CSVCMsg_CreateStringTable::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_CreateStringTable::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* CSVCMsg_CreateStringTable::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional int32 max_entries = 2;
inline bool CSVCMsg_CreateStringTable::has_max_entries() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_CreateStringTable::set_has_max_entries() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_CreateStringTable::clear_has_max_entries() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_CreateStringTable::clear_max_entries() {
  max_entries_ = 0;
  clear_has_max_entries();
}
inline ::google::protobuf::int32 CSVCMsg_CreateStringTable::max_entries() const {
  return max_entries_;
}
inline void CSVCMsg_CreateStringTable::set_max_entries(::google::protobuf::int32 value) {
  set_has_max_entries();
  max_entries_ = value;
}

// optional int32 num_entries = 3;
inline bool CSVCMsg_CreateStringTable::has_num_entries() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CSVCMsg_CreateStringTable::set_has_num_entries() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CSVCMsg_CreateStringTable::clear_has_num_entries() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CSVCMsg_CreateStringTable::clear_num_entries() {
  num_entries_ = 0;
  clear_has_num_entries();
}
inline ::google::protobuf::int32 CSVCMsg_CreateStringTable::num_entries() const {
  return num_entries_;
}
inline void CSVCMsg_CreateStringTable::set_num_entries(::google::protobuf::int32 value) {
  set_has_num_entries();
  num_entries_ = value;
}

// optional bool user_data_fixed_size = 4;
inline bool CSVCMsg_CreateStringTable::has_user_data_fixed_size() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CSVCMsg_CreateStringTable::set_has_user_data_fixed_size() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CSVCMsg_CreateStringTable::clear_has_user_data_fixed_size() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CSVCMsg_CreateStringTable::clear_user_data_fixed_size() {
  user_data_fixed_size_ = false;
  clear_has_user_data_fixed_size();
}
inline bool CSVCMsg_CreateStringTable::user_data_fixed_size() const {
  return user_data_fixed_size_;
}
inline void CSVCMsg_CreateStringTable::set_user_data_fixed_size(bool value) {
  set_has_user_data_fixed_size();
  user_data_fixed_size_ = value;
}

// optional int32 user_data_size = 5;
inline bool CSVCMsg_CreateStringTable::has_user_data_size() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CSVCMsg_CreateStringTable::set_has_user_data_size() {
  _has_bits_[0] |= 0x00000010u;
}
inline void CSVCMsg_CreateStringTable::clear_has_user_data_size() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void CSVCMsg_CreateStringTable::clear_user_data_size() {
  user_data_size_ = 0;
  clear_has_user_data_size();
}
inline ::google::protobuf::int32 CSVCMsg_CreateStringTable::user_data_size() const {
  return user_data_size_;
}
inline void CSVCMsg_CreateStringTable::set_user_data_size(::google::protobuf::int32 value) {
  set_has_user_data_size();
  user_data_size_ = value;
}

// optional int32 user_data_size_bits = 6;
inline bool CSVCMsg_CreateStringTable::has_user_data_size_bits() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void CSVCMsg_CreateStringTable::set_has_user_data_size_bits() {
  _has_bits_[0] |= 0x00000020u;
}
inline void CSVCMsg_CreateStringTable::clear_has_user_data_size_bits() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void CSVCMsg_CreateStringTable::clear_user_data_size_bits() {
  user_data_size_bits_ = 0;
  clear_has_user_data_size_bits();
}
inline ::google::protobuf::int32 CSVCMsg_CreateStringTable::user_data_size_bits() const {
  return user_data_size_bits_;
}
inline void CSVCMsg_CreateStringTable::set_user_data_size_bits(::google::protobuf::int32 value) {
  set_has_user_data_size_bits();
  user_data_size_bits_ = value;
}

// optional int32 flags = 7;
inline bool CSVCMsg_CreateStringTable::has_flags() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void CSVCMsg_CreateStringTable::set_has_flags() {
  _has_bits_[0] |= 0x00000040u;
}
inline void CSVCMsg_CreateStringTable::clear_has_flags() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void CSVCMsg_CreateStringTable::clear_flags() {
  flags_ = 0;
  clear_has_flags();
}
inline ::google::protobuf::int32 CSVCMsg_CreateStringTable::flags() const {
  return flags_;
}
inline void CSVCMsg_CreateStringTable::set_flags(::google::protobuf::int32 value) {
  set_has_flags();
  flags_ = value;
}

// optional bytes string_data = 8;
inline bool CSVCMsg_CreateStringTable::has_string_data() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void CSVCMsg_CreateStringTable::set_has_string_data() {
  _has_bits_[0] |= 0x00000080u;
}
inline void CSVCMsg_CreateStringTable::clear_has_string_data() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void CSVCMsg_CreateStringTable::clear_string_data() {
  if (string_data_ != &::google::protobuf::internal::kEmptyString) {
    string_data_->clear();
  }
  clear_has_string_data();
}
inline const ::std::string& CSVCMsg_CreateStringTable::string_data() const {
  return *string_data_;
}
inline void CSVCMsg_CreateStringTable::set_string_data(const ::std::string& value) {
  set_has_string_data();
  if (string_data_ == &::google::protobuf::internal::kEmptyString) {
    string_data_ = new ::std::string;
  }
  string_data_->assign(value);
}
inline void CSVCMsg_CreateStringTable::set_string_data(const char* value) {
  set_has_string_data();
  if (string_data_ == &::google::protobuf::internal::kEmptyString) {
    string_data_ = new ::std::string;
  }
  string_data_->assign(value);
}
inline void CSVCMsg_CreateStringTable::set_string_data(const void* value, size_t size) {
  set_has_string_data();
  if (string_data_ == &::google::protobuf::internal::kEmptyString) {
    string_data_ = new ::std::string;
  }
  string_data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_CreateStringTable::mutable_string_data() {
  set_has_string_data();
  if (string_data_ == &::google::protobuf::internal::kEmptyString) {
    string_data_ = new ::std::string;
  }
  return string_data_;
}
inline ::std::string* CSVCMsg_CreateStringTable::release_string_data() {
  clear_has_string_data();
  if (string_data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = string_data_;
    string_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CSVCMsg_UpdateStringTable

// optional int32 table_id = 1;
inline bool CSVCMsg_UpdateStringTable::has_table_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_UpdateStringTable::set_has_table_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_UpdateStringTable::clear_has_table_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_UpdateStringTable::clear_table_id() {
  table_id_ = 0;
  clear_has_table_id();
}
inline ::google::protobuf::int32 CSVCMsg_UpdateStringTable::table_id() const {
  return table_id_;
}
inline void CSVCMsg_UpdateStringTable::set_table_id(::google::protobuf::int32 value) {
  set_has_table_id();
  table_id_ = value;
}

// optional int32 num_changed_entries = 2;
inline bool CSVCMsg_UpdateStringTable::has_num_changed_entries() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_UpdateStringTable::set_has_num_changed_entries() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_UpdateStringTable::clear_has_num_changed_entries() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_UpdateStringTable::clear_num_changed_entries() {
  num_changed_entries_ = 0;
  clear_has_num_changed_entries();
}
inline ::google::protobuf::int32 CSVCMsg_UpdateStringTable::num_changed_entries() const {
  return num_changed_entries_;
}
inline void CSVCMsg_UpdateStringTable::set_num_changed_entries(::google::protobuf::int32 value) {
  set_has_num_changed_entries();
  num_changed_entries_ = value;
}

// optional bytes string_data = 3;
inline bool CSVCMsg_UpdateStringTable::has_string_data() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CSVCMsg_UpdateStringTable::set_has_string_data() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CSVCMsg_UpdateStringTable::clear_has_string_data() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CSVCMsg_UpdateStringTable::clear_string_data() {
  if (string_data_ != &::google::protobuf::internal::kEmptyString) {
    string_data_->clear();
  }
  clear_has_string_data();
}
inline const ::std::string& CSVCMsg_UpdateStringTable::string_data() const {
  return *string_data_;
}
inline void CSVCMsg_UpdateStringTable::set_string_data(const ::std::string& value) {
  set_has_string_data();
  if (string_data_ == &::google::protobuf::internal::kEmptyString) {
    string_data_ = new ::std::string;
  }
  string_data_->assign(value);
}
inline void CSVCMsg_UpdateStringTable::set_string_data(const char* value) {
  set_has_string_data();
  if (string_data_ == &::google::protobuf::internal::kEmptyString) {
    string_data_ = new ::std::string;
  }
  string_data_->assign(value);
}
inline void CSVCMsg_UpdateStringTable::set_string_data(const void* value, size_t size) {
  set_has_string_data();
  if (string_data_ == &::google::protobuf::internal::kEmptyString) {
    string_data_ = new ::std::string;
  }
  string_data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_UpdateStringTable::mutable_string_data() {
  set_has_string_data();
  if (string_data_ == &::google::protobuf::internal::kEmptyString) {
    string_data_ = new ::std::string;
  }
  return string_data_;
}
inline ::std::string* CSVCMsg_UpdateStringTable::release_string_data() {
  clear_has_string_data();
  if (string_data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = string_data_;
    string_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CSVCMsg_UserMessage

// optional int32 msg_type = 1;
inline bool CSVCMsg_UserMessage::has_msg_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_UserMessage::set_has_msg_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_UserMessage::clear_has_msg_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_UserMessage::clear_msg_type() {
  msg_type_ = 0;
  clear_has_msg_type();
}
inline ::google::protobuf::int32 CSVCMsg_UserMessage::msg_type() const {
  return msg_type_;
}
inline void CSVCMsg_UserMessage::set_msg_type(::google::protobuf::int32 value) {
  set_has_msg_type();
  msg_type_ = value;
}

// optional bytes msg_data = 2;
inline bool CSVCMsg_UserMessage::has_msg_data() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_UserMessage::set_has_msg_data() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_UserMessage::clear_has_msg_data() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_UserMessage::clear_msg_data() {
  if (msg_data_ != &::google::protobuf::internal::kEmptyString) {
    msg_data_->clear();
  }
  clear_has_msg_data();
}
inline const ::std::string& CSVCMsg_UserMessage::msg_data() const {
  return *msg_data_;
}
inline void CSVCMsg_UserMessage::set_msg_data(const ::std::string& value) {
  set_has_msg_data();
  if (msg_data_ == &::google::protobuf::internal::kEmptyString) {
    msg_data_ = new ::std::string;
  }
  msg_data_->assign(value);
}
inline void CSVCMsg_UserMessage::set_msg_data(const char* value) {
  set_has_msg_data();
  if (msg_data_ == &::google::protobuf::internal::kEmptyString) {
    msg_data_ = new ::std::string;
  }
  msg_data_->assign(value);
}
inline void CSVCMsg_UserMessage::set_msg_data(const void* value, size_t size) {
  set_has_msg_data();
  if (msg_data_ == &::google::protobuf::internal::kEmptyString) {
    msg_data_ = new ::std::string;
  }
  msg_data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_UserMessage::mutable_msg_data() {
  set_has_msg_data();
  if (msg_data_ == &::google::protobuf::internal::kEmptyString) {
    msg_data_ = new ::std::string;
  }
  return msg_data_;
}
inline ::std::string* CSVCMsg_UserMessage::release_msg_data() {
  clear_has_msg_data();
  if (msg_data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = msg_data_;
    msg_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// CSVCMsg_VoiceData

// optional int32 client = 1;
inline bool CSVCMsg_VoiceData::has_client() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_VoiceData::set_has_client() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_VoiceData::clear_has_client() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_VoiceData::clear_client() {
  client_ = 0;
  clear_has_client();
}
inline ::google::protobuf::int32 CSVCMsg_VoiceData::client() const {
  return client_;
}
inline void CSVCMsg_VoiceData::set_client(::google::protobuf::int32 value) {
  set_has_client();
  client_ = value;
}

// optional bool proximity = 2;
inline bool CSVCMsg_VoiceData::has_proximity() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_VoiceData::set_has_proximity() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_VoiceData::clear_has_proximity() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_VoiceData::clear_proximity() {
  proximity_ = false;
  clear_has_proximity();
}
inline bool CSVCMsg_VoiceData::proximity() const {
  return proximity_;
}
inline void CSVCMsg_VoiceData::set_proximity(bool value) {
  set_has_proximity();
  proximity_ = value;
}

// optional fixed64 xuid = 3;
inline bool CSVCMsg_VoiceData::has_xuid() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void CSVCMsg_VoiceData::set_has_xuid() {
  _has_bits_[0] |= 0x00000004u;
}
inline void CSVCMsg_VoiceData::clear_has_xuid() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void CSVCMsg_VoiceData::clear_xuid() {
  xuid_ = GOOGLE_ULONGLONG(0);
  clear_has_xuid();
}
inline ::google::protobuf::uint64 CSVCMsg_VoiceData::xuid() const {
  return xuid_;
}
inline void CSVCMsg_VoiceData::set_xuid(::google::protobuf::uint64 value) {
  set_has_xuid();
  xuid_ = value;
}

// optional int32 audible_mask = 4;
inline bool CSVCMsg_VoiceData::has_audible_mask() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void CSVCMsg_VoiceData::set_has_audible_mask() {
  _has_bits_[0] |= 0x00000008u;
}
inline void CSVCMsg_VoiceData::clear_has_audible_mask() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void CSVCMsg_VoiceData::clear_audible_mask() {
  audible_mask_ = 0;
  clear_has_audible_mask();
}
inline ::google::protobuf::int32 CSVCMsg_VoiceData::audible_mask() const {
  return audible_mask_;
}
inline void CSVCMsg_VoiceData::set_audible_mask(::google::protobuf::int32 value) {
  set_has_audible_mask();
  audible_mask_ = value;
}

// optional bytes voice_data = 5;
inline bool CSVCMsg_VoiceData::has_voice_data() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void CSVCMsg_VoiceData::set_has_voice_data() {
  _has_bits_[0] |= 0x00000010u;
}
inline void CSVCMsg_VoiceData::clear_has_voice_data() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void CSVCMsg_VoiceData::clear_voice_data() {
  if (voice_data_ != &::google::protobuf::internal::kEmptyString) {
    voice_data_->clear();
  }
  clear_has_voice_data();
}
inline const ::std::string& CSVCMsg_VoiceData::voice_data() const {
  return *voice_data_;
}
inline void CSVCMsg_VoiceData::set_voice_data(const ::std::string& value) {
  set_has_voice_data();
  if (voice_data_ == &::google::protobuf::internal::kEmptyString) {
    voice_data_ = new ::std::string;
  }
  voice_data_->assign(value);
}
inline void CSVCMsg_VoiceData::set_voice_data(const char* value) {
  set_has_voice_data();
  if (voice_data_ == &::google::protobuf::internal::kEmptyString) {
    voice_data_ = new ::std::string;
  }
  voice_data_->assign(value);
}
inline void CSVCMsg_VoiceData::set_voice_data(const void* value, size_t size) {
  set_has_voice_data();
  if (voice_data_ == &::google::protobuf::internal::kEmptyString) {
    voice_data_ = new ::std::string;
  }
  voice_data_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* CSVCMsg_VoiceData::mutable_voice_data() {
  set_has_voice_data();
  if (voice_data_ == &::google::protobuf::internal::kEmptyString) {
    voice_data_ = new ::std::string;
  }
  return voice_data_;
}
inline ::std::string* CSVCMsg_VoiceData::release_voice_data() {
  clear_has_voice_data();
  if (voice_data_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = voice_data_;
    voice_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional .VoiceDataFormat_t format = 6 [default = VOICEDATA_FORMAT_STEAM];
inline bool CSVCMsg_VoiceData::has_format() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void CSVCMsg_VoiceData::set_has_format() {
  _has_bits_[0] |= 0x00000020u;
}
inline void CSVCMsg_VoiceData::clear_has_format() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void CSVCMsg_VoiceData::clear_format() {
  format_ = 0;
  clear_has_format();
}
inline VoiceDataFormat_t CSVCMsg_VoiceData::format() const {
  return static_cast< VoiceDataFormat_t >(format_);
}
inline void CSVCMsg_VoiceData::set_format(VoiceDataFormat_t value) {
  GOOGLE_DCHECK(VoiceDataFormat_t_IsValid(value));
  set_has_format();
  format_ = value;
}

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

// CSVCMsgList_GameEvents_event_t

// optional int32 tick = 1;
inline bool CSVCMsgList_GameEvents_event_t::has_tick() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsgList_GameEvents_event_t::set_has_tick() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsgList_GameEvents_event_t::clear_has_tick() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsgList_GameEvents_event_t::clear_tick() {
  tick_ = 0;
  clear_has_tick();
}
inline ::google::protobuf::int32 CSVCMsgList_GameEvents_event_t::tick() const {
  return tick_;
}
inline void CSVCMsgList_GameEvents_event_t::set_tick(::google::protobuf::int32 value) {
  set_has_tick();
  tick_ = value;
}

// optional .CSVCMsg_GameEvent event = 2;
inline bool CSVCMsgList_GameEvents_event_t::has_event() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsgList_GameEvents_event_t::set_has_event() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsgList_GameEvents_event_t::clear_has_event() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsgList_GameEvents_event_t::clear_event() {
  if (event_ != NULL) event_->::CSVCMsg_GameEvent::Clear();
  clear_has_event();
}
inline const ::CSVCMsg_GameEvent& CSVCMsgList_GameEvents_event_t::event() const {
  return event_ != NULL ? *event_ : *default_instance_->event_;
}
inline ::CSVCMsg_GameEvent* CSVCMsgList_GameEvents_event_t::mutable_event() {
  set_has_event();
  if (event_ == NULL) event_ = new ::CSVCMsg_GameEvent;
  return event_;
}
inline ::CSVCMsg_GameEvent* CSVCMsgList_GameEvents_event_t::release_event() {
  clear_has_event();
  ::CSVCMsg_GameEvent* temp = event_;
  event_ = NULL;
  return temp;
}

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

// CSVCMsgList_GameEvents

// repeated .CSVCMsgList_GameEvents.event_t events = 1;
inline int CSVCMsgList_GameEvents::events_size() const {
  return events_.size();
}
inline void CSVCMsgList_GameEvents::clear_events() {
  events_.Clear();
}
inline const ::CSVCMsgList_GameEvents_event_t& CSVCMsgList_GameEvents::events(int index) const {
  return events_.Get(index);
}
inline ::CSVCMsgList_GameEvents_event_t* CSVCMsgList_GameEvents::mutable_events(int index) {
  return events_.Mutable(index);
}
inline ::CSVCMsgList_GameEvents_event_t* CSVCMsgList_GameEvents::add_events() {
  return events_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsgList_GameEvents_event_t >&
CSVCMsgList_GameEvents::events() const {
  return events_;
}
inline ::google::protobuf::RepeatedPtrField< ::CSVCMsgList_GameEvents_event_t >*
CSVCMsgList_GameEvents::mutable_events() {
  return &events_;
}

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

// CSVCMsgList_UserMessages_usermsg_t

// optional int32 tick = 1;
inline bool CSVCMsgList_UserMessages_usermsg_t::has_tick() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsgList_UserMessages_usermsg_t::set_has_tick() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsgList_UserMessages_usermsg_t::clear_has_tick() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsgList_UserMessages_usermsg_t::clear_tick() {
  tick_ = 0;
  clear_has_tick();
}
inline ::google::protobuf::int32 CSVCMsgList_UserMessages_usermsg_t::tick() const {
  return tick_;
}
inline void CSVCMsgList_UserMessages_usermsg_t::set_tick(::google::protobuf::int32 value) {
  set_has_tick();
  tick_ = value;
}

// optional .CSVCMsg_UserMessage msg = 2;
inline bool CSVCMsgList_UserMessages_usermsg_t::has_msg() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsgList_UserMessages_usermsg_t::set_has_msg() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsgList_UserMessages_usermsg_t::clear_has_msg() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsgList_UserMessages_usermsg_t::clear_msg() {
  if (msg_ != NULL) msg_->::CSVCMsg_UserMessage::Clear();
  clear_has_msg();
}
inline const ::CSVCMsg_UserMessage& CSVCMsgList_UserMessages_usermsg_t::msg() const {
  return msg_ != NULL ? *msg_ : *default_instance_->msg_;
}
inline ::CSVCMsg_UserMessage* CSVCMsgList_UserMessages_usermsg_t::mutable_msg() {
  set_has_msg();
  if (msg_ == NULL) msg_ = new ::CSVCMsg_UserMessage;
  return msg_;
}
inline ::CSVCMsg_UserMessage* CSVCMsgList_UserMessages_usermsg_t::release_msg() {
  clear_has_msg();
  ::CSVCMsg_UserMessage* temp = msg_;
  msg_ = NULL;
  return temp;
}

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

// CSVCMsgList_UserMessages

// repeated .CSVCMsgList_UserMessages.usermsg_t usermsgs = 1;
inline int CSVCMsgList_UserMessages::usermsgs_size() const {
  return usermsgs_.size();
}
inline void CSVCMsgList_UserMessages::clear_usermsgs() {
  usermsgs_.Clear();
}
inline const ::CSVCMsgList_UserMessages_usermsg_t& CSVCMsgList_UserMessages::usermsgs(int index) const {
  return usermsgs_.Get(index);
}
inline ::CSVCMsgList_UserMessages_usermsg_t* CSVCMsgList_UserMessages::mutable_usermsgs(int index) {
  return usermsgs_.Mutable(index);
}
inline ::CSVCMsgList_UserMessages_usermsg_t* CSVCMsgList_UserMessages::add_usermsgs() {
  return usermsgs_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::CSVCMsgList_UserMessages_usermsg_t >&
CSVCMsgList_UserMessages::usermsgs() const {
  return usermsgs_;
}
inline ::google::protobuf::RepeatedPtrField< ::CSVCMsgList_UserMessages_usermsg_t >*
CSVCMsgList_UserMessages::mutable_usermsgs() {
  return &usermsgs_;
}

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

// CSVCMsg_PacketReliable

// optional int32 tick = 1;
inline bool CSVCMsg_PacketReliable::has_tick() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CSVCMsg_PacketReliable::set_has_tick() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CSVCMsg_PacketReliable::clear_has_tick() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CSVCMsg_PacketReliable::clear_tick() {
  tick_ = 0;
  clear_has_tick();
}
inline ::google::protobuf::int32 CSVCMsg_PacketReliable::tick() const {
  return tick_;
}
inline void CSVCMsg_PacketReliable::set_tick(::google::protobuf::int32 value) {
  set_has_tick();
  tick_ = value;
}

// optional int32 messagessize = 2;
inline bool CSVCMsg_PacketReliable::has_messagessize() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CSVCMsg_PacketReliable::set_has_messagessize() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CSVCMsg_PacketReliable::clear_has_messagessize() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CSVCMsg_PacketReliable::clear_messagessize() {
  messagessize_ = 0;
  clear_has_messagessize();
}
inline ::google::protobuf::int32 CSVCMsg_PacketReliable::messagessize() const {
  return messagessize_;
}
inline void CSVCMsg_PacketReliable::set_messagessize(::google::protobuf::int32 value) {
  set_has_messagessize();
  messagessize_ = value;
}


// @@protoc_insertion_point(namespace_scope)

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< NET_Messages>() {
  return NET_Messages_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< SIGNONSTATE>() {
  return SIGNONSTATE_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< CLC_Messages>() {
  return CLC_Messages_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< VoiceDataFormat_t>() {
  return VoiceDataFormat_t_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< SVC_Messages>() {
  return SVC_Messages_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ESplitScreenMessageType>() {
  return ESplitScreenMessageType_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_netmessages_2eproto__INCLUDED