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

#ifndef GOOGLE_PROTOBUF_INCLUDED_networkbasetypes_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_networkbasetypes_2eproto

#include <limits>
#include <string>

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

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

// Internal implementation detail -- do not use these members.
struct TableStruct_networkbasetypes_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_networkbasetypes_2eproto;
class CEntityMsg;
struct CEntityMsgDefaultTypeInternal;
extern CEntityMsgDefaultTypeInternal _CEntityMsg_default_instance_;
class CMsgPlayerInfo;
struct CMsgPlayerInfoDefaultTypeInternal;
extern CMsgPlayerInfoDefaultTypeInternal _CMsgPlayerInfo_default_instance_;
class CMsgQAngle;
struct CMsgQAngleDefaultTypeInternal;
extern CMsgQAngleDefaultTypeInternal _CMsgQAngle_default_instance_;
class CMsgQuaternion;
struct CMsgQuaternionDefaultTypeInternal;
extern CMsgQuaternionDefaultTypeInternal _CMsgQuaternion_default_instance_;
class CMsgRGBA;
struct CMsgRGBADefaultTypeInternal;
extern CMsgRGBADefaultTypeInternal _CMsgRGBA_default_instance_;
class CMsgTransform;
struct CMsgTransformDefaultTypeInternal;
extern CMsgTransformDefaultTypeInternal _CMsgTransform_default_instance_;
class CMsgVector;
struct CMsgVectorDefaultTypeInternal;
extern CMsgVectorDefaultTypeInternal _CMsgVector_default_instance_;
class CMsgVector2D;
struct CMsgVector2DDefaultTypeInternal;
extern CMsgVector2DDefaultTypeInternal _CMsgVector2D_default_instance_;
class CMsg_CVars;
struct CMsg_CVarsDefaultTypeInternal;
extern CMsg_CVarsDefaultTypeInternal _CMsg_CVars_default_instance_;
class CMsg_CVars_CVar;
struct CMsg_CVars_CVarDefaultTypeInternal;
extern CMsg_CVars_CVarDefaultTypeInternal _CMsg_CVars_CVar_default_instance_;
class CNETMsg_DebugOverlay;
struct CNETMsg_DebugOverlayDefaultTypeInternal;
extern CNETMsg_DebugOverlayDefaultTypeInternal _CNETMsg_DebugOverlay_default_instance_;
class CNETMsg_NOP;
struct CNETMsg_NOPDefaultTypeInternal;
extern CNETMsg_NOPDefaultTypeInternal _CNETMsg_NOP_default_instance_;
class CNETMsg_SetConVar;
struct CNETMsg_SetConVarDefaultTypeInternal;
extern CNETMsg_SetConVarDefaultTypeInternal _CNETMsg_SetConVar_default_instance_;
class CNETMsg_SignonState;
struct CNETMsg_SignonStateDefaultTypeInternal;
extern CNETMsg_SignonStateDefaultTypeInternal _CNETMsg_SignonState_default_instance_;
class CNETMsg_SpawnGroup_Load;
struct CNETMsg_SpawnGroup_LoadDefaultTypeInternal;
extern CNETMsg_SpawnGroup_LoadDefaultTypeInternal _CNETMsg_SpawnGroup_Load_default_instance_;
class CNETMsg_SpawnGroup_LoadCompleted;
struct CNETMsg_SpawnGroup_LoadCompletedDefaultTypeInternal;
extern CNETMsg_SpawnGroup_LoadCompletedDefaultTypeInternal _CNETMsg_SpawnGroup_LoadCompleted_default_instance_;
class CNETMsg_SpawnGroup_ManifestUpdate;
struct CNETMsg_SpawnGroup_ManifestUpdateDefaultTypeInternal;
extern CNETMsg_SpawnGroup_ManifestUpdateDefaultTypeInternal _CNETMsg_SpawnGroup_ManifestUpdate_default_instance_;
class CNETMsg_SpawnGroup_SetCreationTick;
struct CNETMsg_SpawnGroup_SetCreationTickDefaultTypeInternal;
extern CNETMsg_SpawnGroup_SetCreationTickDefaultTypeInternal _CNETMsg_SpawnGroup_SetCreationTick_default_instance_;
class CNETMsg_SpawnGroup_Unload;
struct CNETMsg_SpawnGroup_UnloadDefaultTypeInternal;
extern CNETMsg_SpawnGroup_UnloadDefaultTypeInternal _CNETMsg_SpawnGroup_Unload_default_instance_;
class CNETMsg_SplitScreenUser;
struct CNETMsg_SplitScreenUserDefaultTypeInternal;
extern CNETMsg_SplitScreenUserDefaultTypeInternal _CNETMsg_SplitScreenUser_default_instance_;
class CNETMsg_StringCmd;
struct CNETMsg_StringCmdDefaultTypeInternal;
extern CNETMsg_StringCmdDefaultTypeInternal _CNETMsg_StringCmd_default_instance_;
class CNETMsg_Tick;
struct CNETMsg_TickDefaultTypeInternal;
extern CNETMsg_TickDefaultTypeInternal _CNETMsg_Tick_default_instance_;
class CSVCMsgList_GameEvents;
struct CSVCMsgList_GameEventsDefaultTypeInternal;
extern CSVCMsgList_GameEventsDefaultTypeInternal _CSVCMsgList_GameEvents_default_instance_;
class CSVCMsgList_GameEvents_event_t;
struct CSVCMsgList_GameEvents_event_tDefaultTypeInternal;
extern CSVCMsgList_GameEvents_event_tDefaultTypeInternal _CSVCMsgList_GameEvents_event_t_default_instance_;
class CSVCMsg_GameEvent;
struct CSVCMsg_GameEventDefaultTypeInternal;
extern CSVCMsg_GameEventDefaultTypeInternal _CSVCMsg_GameEvent_default_instance_;
class CSVCMsg_GameEvent_key_t;
struct CSVCMsg_GameEvent_key_tDefaultTypeInternal;
extern CSVCMsg_GameEvent_key_tDefaultTypeInternal _CSVCMsg_GameEvent_key_t_default_instance_;
class CSVCMsg_GameSessionConfiguration;
struct CSVCMsg_GameSessionConfigurationDefaultTypeInternal;
extern CSVCMsg_GameSessionConfigurationDefaultTypeInternal _CSVCMsg_GameSessionConfiguration_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::CEntityMsg* Arena::CreateMaybeMessage<::CEntityMsg>(Arena*);
template<> ::CMsgPlayerInfo* Arena::CreateMaybeMessage<::CMsgPlayerInfo>(Arena*);
template<> ::CMsgQAngle* Arena::CreateMaybeMessage<::CMsgQAngle>(Arena*);
template<> ::CMsgQuaternion* Arena::CreateMaybeMessage<::CMsgQuaternion>(Arena*);
template<> ::CMsgRGBA* Arena::CreateMaybeMessage<::CMsgRGBA>(Arena*);
template<> ::CMsgTransform* Arena::CreateMaybeMessage<::CMsgTransform>(Arena*);
template<> ::CMsgVector* Arena::CreateMaybeMessage<::CMsgVector>(Arena*);
template<> ::CMsgVector2D* Arena::CreateMaybeMessage<::CMsgVector2D>(Arena*);
template<> ::CMsg_CVars* Arena::CreateMaybeMessage<::CMsg_CVars>(Arena*);
template<> ::CMsg_CVars_CVar* Arena::CreateMaybeMessage<::CMsg_CVars_CVar>(Arena*);
template<> ::CNETMsg_DebugOverlay* Arena::CreateMaybeMessage<::CNETMsg_DebugOverlay>(Arena*);
template<> ::CNETMsg_NOP* Arena::CreateMaybeMessage<::CNETMsg_NOP>(Arena*);
template<> ::CNETMsg_SetConVar* Arena::CreateMaybeMessage<::CNETMsg_SetConVar>(Arena*);
template<> ::CNETMsg_SignonState* Arena::CreateMaybeMessage<::CNETMsg_SignonState>(Arena*);
template<> ::CNETMsg_SpawnGroup_Load* Arena::CreateMaybeMessage<::CNETMsg_SpawnGroup_Load>(Arena*);
template<> ::CNETMsg_SpawnGroup_LoadCompleted* Arena::CreateMaybeMessage<::CNETMsg_SpawnGroup_LoadCompleted>(Arena*);
template<> ::CNETMsg_SpawnGroup_ManifestUpdate* Arena::CreateMaybeMessage<::CNETMsg_SpawnGroup_ManifestUpdate>(Arena*);
template<> ::CNETMsg_SpawnGroup_SetCreationTick* Arena::CreateMaybeMessage<::CNETMsg_SpawnGroup_SetCreationTick>(Arena*);
template<> ::CNETMsg_SpawnGroup_Unload* Arena::CreateMaybeMessage<::CNETMsg_SpawnGroup_Unload>(Arena*);
template<> ::CNETMsg_SplitScreenUser* Arena::CreateMaybeMessage<::CNETMsg_SplitScreenUser>(Arena*);
template<> ::CNETMsg_StringCmd* Arena::CreateMaybeMessage<::CNETMsg_StringCmd>(Arena*);
template<> ::CNETMsg_Tick* Arena::CreateMaybeMessage<::CNETMsg_Tick>(Arena*);
template<> ::CSVCMsgList_GameEvents* Arena::CreateMaybeMessage<::CSVCMsgList_GameEvents>(Arena*);
template<> ::CSVCMsgList_GameEvents_event_t* Arena::CreateMaybeMessage<::CSVCMsgList_GameEvents_event_t>(Arena*);
template<> ::CSVCMsg_GameEvent* Arena::CreateMaybeMessage<::CSVCMsg_GameEvent>(Arena*);
template<> ::CSVCMsg_GameEvent_key_t* Arena::CreateMaybeMessage<::CSVCMsg_GameEvent_key_t>(Arena*);
template<> ::CSVCMsg_GameSessionConfiguration* Arena::CreateMaybeMessage<::CSVCMsg_GameSessionConfiguration>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum SignonState_t : int {
  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_t_IsValid(int value);
constexpr SignonState_t SignonState_t_MIN = SIGNONSTATE_NONE;
constexpr SignonState_t SignonState_t_MAX = SIGNONSTATE_CHANGELEVEL;
constexpr int SignonState_t_ARRAYSIZE = SignonState_t_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SignonState_t_descriptor();
template<typename T>
inline const std::string& SignonState_t_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SignonState_t>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SignonState_t_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SignonState_t_descriptor(), enum_t_value);
}
inline bool SignonState_t_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SignonState_t* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SignonState_t>(
    SignonState_t_descriptor(), name, value);
}
enum NET_Messages : int {
  net_NOP = 0,
  net_Disconnect_Legacy = 1,
  net_SplitScreenUser = 3,
  net_Tick = 4,
  net_StringCmd = 5,
  net_SetConVar = 6,
  net_SignonState = 7,
  net_SpawnGroup_Load = 8,
  net_SpawnGroup_ManifestUpdate = 9,
  net_SpawnGroup_SetCreationTick = 11,
  net_SpawnGroup_Unload = 12,
  net_SpawnGroup_LoadCompleted = 13,
  net_DebugOverlay = 15
};
bool NET_Messages_IsValid(int value);
constexpr NET_Messages NET_Messages_MIN = net_NOP;
constexpr NET_Messages NET_Messages_MAX = net_DebugOverlay;
constexpr int NET_Messages_ARRAYSIZE = NET_Messages_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NET_Messages_descriptor();
template<typename T>
inline const std::string& NET_Messages_Name(T enum_t_value) {
  static_assert(::std::is_same<T, NET_Messages>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function NET_Messages_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    NET_Messages_descriptor(), enum_t_value);
}
inline bool NET_Messages_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NET_Messages* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NET_Messages>(
    NET_Messages_descriptor(), name, value);
}
enum SpawnGroupFlags_t : int {
  SPAWN_GROUP_LOAD_ENTITIES_FROM_SAVE = 1,
  SPAWN_GROUP_DONT_SPAWN_ENTITIES = 2,
  SPAWN_GROUP_SYNCHRONOUS_SPAWN = 4,
  SPAWN_GROUP_IS_INITIAL_SPAWN_GROUP = 8,
  SPAWN_GROUP_CREATE_CLIENT_ONLY_ENTITIES = 16,
  SPAWN_GROUP_BLOCK_UNTIL_LOADED = 64,
  SPAWN_GROUP_LOAD_STREAMING_DATA = 128,
  SPAWN_GROUP_CREATE_NEW_SCENE_WORLD = 256
};
bool SpawnGroupFlags_t_IsValid(int value);
constexpr SpawnGroupFlags_t SpawnGroupFlags_t_MIN = SPAWN_GROUP_LOAD_ENTITIES_FROM_SAVE;
constexpr SpawnGroupFlags_t SpawnGroupFlags_t_MAX = SPAWN_GROUP_CREATE_NEW_SCENE_WORLD;
constexpr int SpawnGroupFlags_t_ARRAYSIZE = SpawnGroupFlags_t_MAX + 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kXFieldNumber = 1,
    kYFieldNumber = 2,
    kZFieldNumber = 3,
    kWFieldNumber = 4,
  };
  // optional float x = 1;
  bool has_x() const;
  private:
  bool _internal_has_x() const;
  public:
  void clear_x();
  float x() const;
  void set_x(float value);
  private:
  float _internal_x() const;
  void _internal_set_x(float value);
  public:

  // optional float y = 2;
  bool has_y() const;
  private:
  bool _internal_has_y() const;
  public:
  void clear_y();
  float y() const;
  void set_y(float value);
  private:
  float _internal_y() const;
  void _internal_set_y(float value);
  public:

  // optional float z = 3;
  bool has_z() const;
  private:
  bool _internal_has_z() const;
  public:
  void clear_z();
  float z() const;
  void set_z(float value);
  private:
  float _internal_z() const;
  void _internal_set_z(float value);
  public:

  // optional float w = 4;
  bool has_w() const;
  private:
  bool _internal_has_w() const;
  public:
  void clear_w();
  float w() const;
  void set_w(float value);
  private:
  float _internal_w() const;
  void _internal_set_w(float value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float x_;
    float y_;
    float z_;
    float w_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_networkbasetypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kXFieldNumber = 1,
    kYFieldNumber = 2,
  };
  // optional float x = 1;
  bool has_x() const;
  private:
  bool _internal_has_x() const;
  public:
  void clear_x();
  float x() const;
  void set_x(float value);
  private:
  float _internal_x() const;
  void _internal_set_x(float value);
  public:

  // optional float y = 2;
  bool has_y() const;
  private:
  bool _internal_has_y() const;
  public:
  void clear_y();
  float y() const;
  void set_y(float value);
  private:
  float _internal_y() const;
  void _internal_set_y(float value);
  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kXFieldNumber = 1,
    kYFieldNumber = 2,
    kZFieldNumber = 3,
  };
  // optional float x = 1;
  bool has_x() const;
  private:
  bool _internal_has_x() const;
  public:
  void clear_x();
  float x() const;
  void set_x(float value);
  private:
  float _internal_x() const;
  void _internal_set_x(float value);
  public:

  // optional float y = 2;
  bool has_y() const;
  private:
  bool _internal_has_y() const;
  public:
  void clear_y();
  float y() const;
  void set_y(float value);
  private:
  float _internal_y() const;
  void _internal_set_y(float value);
  public:

  // optional float z = 3;
  bool has_z() const;
  private:
  bool _internal_has_z() const;
  public:
  void clear_z();
  float z() const;
  void set_z(float value);
  private:
  float _internal_z() const;
  void _internal_set_z(float value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float x_;
    float y_;
    float z_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_networkbasetypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kXFieldNumber = 1,
    kYFieldNumber = 2,
    kZFieldNumber = 3,
    kWFieldNumber = 4,
  };
  // optional float x = 1;
  bool has_x() const;
  private:
  bool _internal_has_x() const;
  public:
  void clear_x();
  float x() const;
  void set_x(float value);
  private:
  float _internal_x() const;
  void _internal_set_x(float value);
  public:

  // optional float y = 2;
  bool has_y() const;
  private:
  bool _internal_has_y() const;
  public:
  void clear_y();
  float y() const;
  void set_y(float value);
  private:
  float _internal_y() const;
  void _internal_set_y(float value);
  public:

  // optional float z = 3;
  bool has_z() const;
  private:
  bool _internal_has_z() const;
  public:
  void clear_z();
  float z() const;
  void set_z(float value);
  private:
  float _internal_z() const;
  void _internal_set_z(float value);
  public:

  // optional float w = 4;
  bool has_w() const;
  private:
  bool _internal_has_w() const;
  public:
  void clear_w();
  float w() const;
  void set_w(float value);
  private:
  float _internal_w() const;
  void _internal_set_w(float value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    float x_;
    float y_;
    float z_;
    float w_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_networkbasetypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kPositionFieldNumber = 1,
    kOrientationFieldNumber = 3,
    kScaleFieldNumber = 2,
  };
  // optional .CMsgVector position = 1;
  bool has_position() const;
  private:
  bool _internal_has_position() const;
  public:
  void clear_position();
  const ::CMsgVector& position() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_position();
  ::CMsgVector* mutable_position();
  void set_allocated_position(::CMsgVector* position);
  private:
  const ::CMsgVector& _internal_position() const;
  ::CMsgVector* _internal_mutable_position();
  public:
  void unsafe_arena_set_allocated_position(
      ::CMsgVector* position);
  ::CMsgVector* unsafe_arena_release_position();

  // optional .CMsgQuaternion orientation = 3;
  bool has_orientation() const;
  private:
  bool _internal_has_orientation() const;
  public:
  void clear_orientation();
  const ::CMsgQuaternion& orientation() const;
  PROTOBUF_NODISCARD ::CMsgQuaternion* release_orientation();
  ::CMsgQuaternion* mutable_orientation();
  void set_allocated_orientation(::CMsgQuaternion* orientation);
  private:
  const ::CMsgQuaternion& _internal_orientation() const;
  ::CMsgQuaternion* _internal_mutable_orientation();
  public:
  void unsafe_arena_set_allocated_orientation(
      ::CMsgQuaternion* orientation);
  ::CMsgQuaternion* unsafe_arena_release_orientation();

  // optional float scale = 2;
  bool has_scale() const;
  private:
  bool _internal_has_scale() const;
  public:
  void clear_scale();
  float scale() const;
  void set_scale(float value);
  private:
  float _internal_scale() const;
  void _internal_set_scale(float value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::CMsgVector* position_;
    ::CMsgQuaternion* orientation_;
    float scale_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_networkbasetypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kRFieldNumber = 1,
    kGFieldNumber = 2,
    kBFieldNumber = 3,
    kAFieldNumber = 4,
  };
  // optional int32 r = 1;
  bool has_r() const;
  private:
  bool _internal_has_r() const;
  public:
  void clear_r();
  int32_t r() const;
  void set_r(int32_t value);
  private:
  int32_t _internal_r() const;
  void _internal_set_r(int32_t value);
  public:

  // optional int32 g = 2;
  bool has_g() const;
  private:
  bool _internal_has_g() const;
  public:
  void clear_g();
  int32_t g() const;
  void set_g(int32_t value);
  private:
  int32_t _internal_g() const;
  void _internal_set_g(int32_t value);
  public:

  // optional int32 b = 3;
  bool has_b() const;
  private:
  bool _internal_has_b() const;
  public:
  void clear_b();
  int32_t b() const;
  void set_b(int32_t value);
  private:
  int32_t _internal_b() const;
  void _internal_set_b(int32_t value);
  public:

  // optional int32 a = 4;
  bool has_a() const;
  private:
  bool _internal_has_a() const;
  public:
  void clear_a();
  int32_t a() const;
  void set_a(int32_t value);
  private:
  int32_t _internal_a() const;
  void _internal_set_a(int32_t value);
  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  // optional fixed64 steamid = 4;
  bool has_steamid() const;
  private:
  bool _internal_has_steamid() const;
  public:
  void clear_steamid();
  uint64_t steamid() const;
  void set_steamid(uint64_t value);
  private:
  uint64_t _internal_steamid() const;
  void _internal_set_steamid(uint64_t value);
  public:

  // optional int32 userid = 3;
  bool has_userid() const;
  private:
  bool _internal_has_userid() const;
  public:
  void clear_userid();
  int32_t userid() const;
  void set_userid(int32_t value);
  private:
  int32_t _internal_userid() const;
  void _internal_set_userid(int32_t value);
  public:

  // optional bool fakeplayer = 5;
  bool has_fakeplayer() const;
  private:
  bool _internal_has_fakeplayer() const;
  public:
  void clear_fakeplayer();
  bool fakeplayer() const;
  void set_fakeplayer(bool value);
  private:
  bool _internal_fakeplayer() const;
  void _internal_set_fakeplayer(bool value);
  public:

  // optional bool ishltv = 6;
  bool has_ishltv() const;
  private:
  bool _internal_has_ishltv() const;
  public:
  void clear_ishltv();
  bool ishltv() const;
  void set_ishltv(bool value);
  private:
  bool _internal_ishltv() const;
  void _internal_set_ishltv(bool value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    uint64_t xuid_;
    uint64_t steamid_;
    int32_t userid_;
    bool fakeplayer_;
    bool ishltv_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_networkbasetypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kTargetEntityFieldNumber = 1,
  };
  // optional uint32 target_entity = 1 [default = 16777215];
  bool has_target_entity() const;
  private:
  bool _internal_has_target_entity() const;
  public:
  void clear_target_entity();
  uint32_t target_entity() const;
  void set_target_entity(uint32_t value);
  private:
  uint32_t _internal_target_entity() const;
  void _internal_set_target_entity(uint32_t value);
  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  // @@protoc_insertion_point(class_scope:CMsg_CVars.CVar)
 private:
  class _Internal;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  typedef CMsg_CVars_CVar CVar;

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

  enum : int {
    kCvarsFieldNumber = 1,
  };
  // repeated .CMsg_CVars.CVar cvars = 1;
  int cvars_size() const;
  private:
  int _internal_cvars_size() const;
  public:
  void clear_cvars();
  ::CMsg_CVars_CVar* mutable_cvars(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsg_CVars_CVar >*
      mutable_cvars();
  private:
  const ::CMsg_CVars_CVar& _internal_cvars(int index) const;
  ::CMsg_CVars_CVar* _internal_add_cvars();
  public:
  const ::CMsg_CVars_CVar& cvars(int index) const;
  ::CMsg_CVars_CVar* add_cvars();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsg_CVars_CVar >&
      cvars() const;

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

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

class CNETMsg_NOP final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:CNETMsg_NOP) */ {
 public:
  inline CNETMsg_NOP() : CNETMsg_NOP(nullptr) {}
  explicit PROTOBUF_CONSTEXPR CNETMsg_NOP(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

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

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

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

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

  CNETMsg_NOP* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CNETMsg_NOP>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const CNETMsg_NOP& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const CNETMsg_NOP& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

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

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

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

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

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

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_networkbasetypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kExpectedLongTickReasonFieldNumber = 11,
    kTickFieldNumber = 1,
    kHostComputationtimeFieldNumber = 4,
    kHostComputationtimeStdDeviationFieldNumber = 5,
    kLegacyHostLossFieldNumber = 7,
    kHostUnfilteredFrametimeFieldNumber = 8,
    kHltvReplayFlagsFieldNumber = 9,
    kExpectedLongTickFieldNumber = 10,
    kHostFrameDroppedPctX10FieldNumber = 12,
    kHostFrameIrregularArrivalPctX10FieldNumber = 13,
  };
  // optional string expected_long_tick_reason = 11;
  bool has_expected_long_tick_reason() const;
  private:
  bool _internal_has_expected_long_tick_reason() const;
  public:
  void clear_expected_long_tick_reason();
  const std::string& expected_long_tick_reason() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_expected_long_tick_reason(ArgT0&& arg0, ArgT... args);
  std::string* mutable_expected_long_tick_reason();
  PROTOBUF_NODISCARD std::string* release_expected_long_tick_reason();
  void set_allocated_expected_long_tick_reason(std::string* expected_long_tick_reason);
  private:
  const std::string& _internal_expected_long_tick_reason() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_expected_long_tick_reason(const std::string& value);
  std::string* _internal_mutable_expected_long_tick_reason();
  public:

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

  // optional uint32 host_computationtime = 4;
  bool has_host_computationtime() const;
  private:
  bool _internal_has_host_computationtime() const;
  public:
  void clear_host_computationtime();
  uint32_t host_computationtime() const;
  void set_host_computationtime(uint32_t value);
  private:
  uint32_t _internal_host_computationtime() const;
  void _internal_set_host_computationtime(uint32_t value);
  public:

  // optional uint32 host_computationtime_std_deviation = 5;
  bool has_host_computationtime_std_deviation() const;
  private:
  bool _internal_has_host_computationtime_std_deviation() const;
  public:
  void clear_host_computationtime_std_deviation();
  uint32_t host_computationtime_std_deviation() const;
  void set_host_computationtime_std_deviation(uint32_t value);
  private:
  uint32_t _internal_host_computationtime_std_deviation() const;
  void _internal_set_host_computationtime_std_deviation(uint32_t value);
  public:

  // optional uint32 legacy_host_loss = 7;
  bool has_legacy_host_loss() const;
  private:
  bool _internal_has_legacy_host_loss() const;
  public:
  void clear_legacy_host_loss();
  uint32_t legacy_host_loss() const;
  void set_legacy_host_loss(uint32_t value);
  private:
  uint32_t _internal_legacy_host_loss() const;
  void _internal_set_legacy_host_loss(uint32_t value);
  public:

  // optional uint32 host_unfiltered_frametime = 8;
  bool has_host_unfiltered_frametime() const;
  private:
  bool _internal_has_host_unfiltered_frametime() const;
  public:
  void clear_host_unfiltered_frametime();
  uint32_t host_unfiltered_frametime() const;
  void set_host_unfiltered_frametime(uint32_t value);
  private:
  uint32_t _internal_host_unfiltered_frametime() const;
  void _internal_set_host_unfiltered_frametime(uint32_t value);
  public:

  // optional uint32 hltv_replay_flags = 9;
  bool has_hltv_replay_flags() const;
  private:
  bool _internal_has_hltv_replay_flags() const;
  public:
  void clear_hltv_replay_flags();
  uint32_t hltv_replay_flags() const;
  void set_hltv_replay_flags(uint32_t value);
  private:
  uint32_t _internal_hltv_replay_flags() const;
  void _internal_set_hltv_replay_flags(uint32_t value);
  public:

  // optional uint32 expected_long_tick = 10;
  bool has_expected_long_tick() const;
  private:
  bool _internal_has_expected_long_tick() const;
  public:
  void clear_expected_long_tick();
  uint32_t expected_long_tick() const;
  void set_expected_long_tick(uint32_t value);
  private:
  uint32_t _internal_expected_long_tick() const;
  void _internal_set_expected_long_tick(uint32_t value);
  public:

  // optional uint32 host_frame_dropped_pct_x10 = 12;
  bool has_host_frame_dropped_pct_x10() const;
  private:
  bool _internal_has_host_frame_dropped_pct_x10() const;
  public:
  void clear_host_frame_dropped_pct_x10();
  uint32_t host_frame_dropped_pct_x10() const;
  void set_host_frame_dropped_pct_x10(uint32_t value);
  private:
  uint32_t _internal_host_frame_dropped_pct_x10() const;
  void _internal_set_host_frame_dropped_pct_x10(uint32_t value);
  public:

  // optional uint32 host_frame_irregular_arrival_pct_x10 = 13;
  bool has_host_frame_irregular_arrival_pct_x10() const;
  private:
  bool _internal_has_host_frame_irregular_arrival_pct_x10() const;
  public:
  void clear_host_frame_irregular_arrival_pct_x10();
  uint32_t host_frame_irregular_arrival_pct_x10() const;
  void set_host_frame_irregular_arrival_pct_x10(uint32_t value);
  private:
  uint32_t _internal_host_frame_irregular_arrival_pct_x10() const;
  void _internal_set_host_frame_irregular_arrival_pct_x10(uint32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr expected_long_tick_reason_;
    uint32_t tick_;
    uint32_t host_computationtime_;
    uint32_t host_computationtime_std_deviation_;
    uint32_t legacy_host_loss_;
    uint32_t host_unfiltered_frametime_;
    uint32_t hltv_replay_flags_;
    uint32_t expected_long_tick_;
    uint32_t host_frame_dropped_pct_x10_;
    uint32_t host_frame_irregular_arrival_pct_x10_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_networkbasetypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kCommandFieldNumber = 1,
    kPredictionSyncFieldNumber = 2,
  };
  // optional string command = 1;
  bool has_command() const;
  private:
  bool _internal_has_command() const;
  public:
  void clear_command();
  const std::string& command() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_command(ArgT0&& arg0, ArgT... args);
  std::string* mutable_command();
  PROTOBUF_NODISCARD std::string* release_command();
  void set_allocated_command(std::string* command);
  private:
  const std::string& _internal_command() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_command(const std::string& value);
  std::string* _internal_mutable_command();
  public:

  // optional uint32 prediction_sync = 2;
  bool has_prediction_sync() const;
  private:
  bool _internal_has_prediction_sync() const;
  public:
  void clear_prediction_sync();
  uint32_t prediction_sync() const;
  void set_prediction_sync(uint32_t value);
  private:
  uint32_t _internal_prediction_sync() const;
  void _internal_set_prediction_sync(uint32_t value);
  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kConvarsFieldNumber = 1,
  };
  // optional .CMsg_CVars convars = 1;
  bool has_convars() const;
  private:
  bool _internal_has_convars() const;
  public:
  void clear_convars();
  const ::CMsg_CVars& convars() const;
  PROTOBUF_NODISCARD ::CMsg_CVars* release_convars();
  ::CMsg_CVars* mutable_convars();
  void set_allocated_convars(::CMsg_CVars* convars);
  private:
  const ::CMsg_CVars& _internal_convars() const;
  ::CMsg_CVars* _internal_mutable_convars();
  public:
  void unsafe_arena_set_allocated_convars(
      ::CMsg_CVars* convars);
  ::CMsg_CVars* unsafe_arena_release_convars();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kPlayersNetworkidsFieldNumber = 4,
    kMapNameFieldNumber = 5,
    kAddonsFieldNumber = 6,
    kSignonStateFieldNumber = 1,
    kSpawnCountFieldNumber = 2,
    kNumServerPlayersFieldNumber = 3,
  };
  // repeated string players_networkids = 4;
  int players_networkids_size() const;
  private:
  int _internal_players_networkids_size() const;
  public:
  void clear_players_networkids();
  const std::string& players_networkids(int index) const;
  std::string* mutable_players_networkids(int index);
  void set_players_networkids(int index, const std::string& value);
  void set_players_networkids(int index, std::string&& value);
  void set_players_networkids(int index, const char* value);
  void set_players_networkids(int index, const char* value, size_t size);
  std::string* add_players_networkids();
  void add_players_networkids(const std::string& value);
  void add_players_networkids(std::string&& value);
  void add_players_networkids(const char* value);
  void add_players_networkids(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& players_networkids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_players_networkids();
  private:
  const std::string& _internal_players_networkids(int index) const;
  std::string* _internal_add_players_networkids();
  public:

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

  // optional string addons = 6;
  bool has_addons() const;
  private:
  bool _internal_has_addons() const;
  public:
  void clear_addons();
  const std::string& addons() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_addons(ArgT0&& arg0, ArgT... args);
  std::string* mutable_addons();
  PROTOBUF_NODISCARD std::string* release_addons();
  void set_allocated_addons(std::string* addons);
  private:
  const std::string& _internal_addons() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_addons(const std::string& value);
  std::string* _internal_mutable_addons();
  public:

  // optional .SignonState_t signon_state = 1 [default = SIGNONSTATE_NONE];
  bool has_signon_state() const;
  private:
  bool _internal_has_signon_state() const;
  public:
  void clear_signon_state();
  ::SignonState_t signon_state() const;
  void set_signon_state(::SignonState_t value);
  private:
  ::SignonState_t _internal_signon_state() const;
  void _internal_set_signon_state(::SignonState_t value);
  public:

  // optional uint32 spawn_count = 2;
  bool has_spawn_count() const;
  private:
  bool _internal_has_spawn_count() const;
  public:
  void clear_spawn_count();
  uint32_t spawn_count() const;
  void set_spawn_count(uint32_t value);
  private:
  uint32_t _internal_spawn_count() const;
  void _internal_set_spawn_count(uint32_t value);
  public:

  // optional uint32 num_server_players = 3;
  bool has_num_server_players() const;
  private:
  bool _internal_has_num_server_players() const;
  public:
  void clear_num_server_players();
  uint32_t num_server_players() const;
  void set_num_server_players(uint32_t value);
  private:
  uint32_t _internal_num_server_players() const;
  void _internal_set_num_server_players(uint32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> players_networkids_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr addons_;
    int signon_state_;
    uint32_t spawn_count_;
    uint32_t num_server_players_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_networkbasetypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kValStringFieldNumber = 2,
    kTypeFieldNumber = 1,
    kValFloatFieldNumber = 3,
    kValLongFieldNumber = 4,
    kValShortFieldNumber = 5,
    kValByteFieldNumber = 6,
    kValBoolFieldNumber = 7,
    kValUint64FieldNumber = 8,
  };
  // optional string val_string = 2;
  bool has_val_string() const;
  private:
  bool _internal_has_val_string() const;
  public:
  void clear_val_string();
  const std::string& val_string() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_val_string(ArgT0&& arg0, ArgT... args);
  std::string* mutable_val_string();
  PROTOBUF_NODISCARD std::string* release_val_string();
  void set_allocated_val_string(std::string* val_string);
  private:
  const std::string& _internal_val_string() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_val_string(const std::string& value);
  std::string* _internal_mutable_val_string();
  public:

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

  // optional float val_float = 3;
  bool has_val_float() const;
  private:
  bool _internal_has_val_float() const;
  public:
  void clear_val_float();
  float val_float() const;
  void set_val_float(float value);
  private:
  float _internal_val_float() const;
  void _internal_set_val_float(float value);
  public:

  // optional int32 val_long = 4;
  bool has_val_long() const;
  private:
  bool _internal_has_val_long() const;
  public:
  void clear_val_long();
  int32_t val_long() const;
  void set_val_long(int32_t value);
  private:
  int32_t _internal_val_long() const;
  void _internal_set_val_long(int32_t value);
  public:

  // optional int32 val_short = 5;
  bool has_val_short() const;
  private:
  bool _internal_has_val_short() const;
  public:
  void clear_val_short();
  int32_t val_short() const;
  void set_val_short(int32_t value);
  private:
  int32_t _internal_val_short() const;
  void _internal_set_val_short(int32_t value);
  public:

  // optional int32 val_byte = 6;
  bool has_val_byte() const;
  private:
  bool _internal_has_val_byte() const;
  public:
  void clear_val_byte();
  int32_t val_byte() const;
  void set_val_byte(int32_t value);
  private:
  int32_t _internal_val_byte() const;
  void _internal_set_val_byte(int32_t value);
  public:

  // optional bool val_bool = 7;
  bool has_val_bool() const;
  private:
  bool _internal_has_val_bool() const;
  public:
  void clear_val_bool();
  bool val_bool() const;
  void set_val_bool(bool value);
  private:
  bool _internal_val_bool() const;
  void _internal_set_val_bool(bool value);
  public:

  // optional uint64 val_uint64 = 8;
  bool has_val_uint64() const;
  private:
  bool _internal_has_val_uint64() const;
  public:
  void clear_val_uint64();
  uint64_t val_uint64() const;
  void set_val_uint64(uint64_t value);
  private:
  uint64_t _internal_val_uint64() const;
  void _internal_set_val_uint64(uint64_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr val_string_;
    int32_t type_;
    float val_float_;
    int32_t val_long_;
    int32_t val_short_;
    int32_t val_byte_;
    bool val_bool_;
    uint64_t val_uint64_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_networkbasetypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  typedef CSVCMsg_GameEvent_key_t key_t;

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

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

  // optional string event_name = 1;
  bool has_event_name() const;
  private:
  bool _internal_has_event_name() const;
  public:
  void clear_event_name();
  const std::string& event_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_event_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_event_name();
  PROTOBUF_NODISCARD std::string* release_event_name();
  void set_allocated_event_name(std::string* event_name);
  private:
  const std::string& _internal_event_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_event_name(const std::string& value);
  std::string* _internal_mutable_event_name();
  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kEventFieldNumber = 2,
    kTickFieldNumber = 1,
  };
  // optional .CSVCMsg_GameEvent event = 2;
  bool has_event() const;
  private:
  bool _internal_has_event() const;
  public:
  void clear_event();
  const ::CSVCMsg_GameEvent& event() const;
  PROTOBUF_NODISCARD ::CSVCMsg_GameEvent* release_event();
  ::CSVCMsg_GameEvent* mutable_event();
  void set_allocated_event(::CSVCMsg_GameEvent* event);
  private:
  const ::CSVCMsg_GameEvent& _internal_event() const;
  ::CSVCMsg_GameEvent* _internal_mutable_event();
  public:
  void unsafe_arena_set_allocated_event(
      ::CSVCMsg_GameEvent* event);
  ::CSVCMsg_GameEvent* unsafe_arena_release_event();

  // optional int32 tick = 1;
  bool has_tick() const;
  private:
  bool _internal_has_tick() const;
  public:
  void clear_tick();
  int32_t tick() const;
  void set_tick(int32_t value);
  private:
  int32_t _internal_tick() const;
  void _internal_set_tick(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CSVCMsgList_GameEvents.event_t)
 private:
  class _Internal;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  typedef CSVCMsgList_GameEvents_event_t event_t;

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

  enum : int {
    kEventsFieldNumber = 1,
  };
  // repeated .CSVCMsgList_GameEvents.event_t events = 1;
  int events_size() const;
  private:
  int _internal_events_size() const;
  public:
  void clear_events();
  ::CSVCMsgList_GameEvents_event_t* mutable_events(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsgList_GameEvents_event_t >*
      mutable_events();
  private:
  const ::CSVCMsgList_GameEvents_event_t& _internal_events(int index) const;
  ::CSVCMsgList_GameEvents_event_t* _internal_add_events();
  public:
  const ::CSVCMsgList_GameEvents_event_t& events(int index) const;
  ::CSVCMsgList_GameEvents_event_t* add_events();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsgList_GameEvents_event_t >&
      events() const;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kWorldnameFieldNumber = 1,
    kEntitylumpnameFieldNumber = 2,
    kEntityfilternameFieldNumber = 3,
    kSpawngroupmanifestFieldNumber = 8,
    kLocalnamefixupFieldNumber = 12,
    kParentnamefixupFieldNumber = 13,
    kSavegamefilenameFieldNumber = 17,
    kWorldgroupnameFieldNumber = 20,
    kWorldOffsetPosFieldNumber = 6,
    kWorldOffsetAngleFieldNumber = 7,
    kSpawngrouphandleFieldNumber = 4,
    kSpawngroupownerhandleFieldNumber = 5,
    kFlagsFieldNumber = 9,
    kTickcountFieldNumber = 10,
    kManifestloadpriorityFieldNumber = 14,
    kWorldgroupidFieldNumber = 15,
    kManifestincompleteFieldNumber = 11,
    kLeveltransitionFieldNumber = 19,
    kCreationsequenceFieldNumber = 16,
    kSpawngroupparenthandleFieldNumber = 18,
  };
  // optional string worldname = 1;
  bool has_worldname() const;
  private:
  bool _internal_has_worldname() const;
  public:
  void clear_worldname();
  const std::string& worldname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_worldname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_worldname();
  PROTOBUF_NODISCARD std::string* release_worldname();
  void set_allocated_worldname(std::string* worldname);
  private:
  const std::string& _internal_worldname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_worldname(const std::string& value);
  std::string* _internal_mutable_worldname();
  public:

  // optional string entitylumpname = 2;
  bool has_entitylumpname() const;
  private:
  bool _internal_has_entitylumpname() const;
  public:
  void clear_entitylumpname();
  const std::string& entitylumpname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_entitylumpname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_entitylumpname();
  PROTOBUF_NODISCARD std::string* release_entitylumpname();
  void set_allocated_entitylumpname(std::string* entitylumpname);
  private:
  const std::string& _internal_entitylumpname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_entitylumpname(const std::string& value);
  std::string* _internal_mutable_entitylumpname();
  public:

  // optional string entityfiltername = 3;
  bool has_entityfiltername() const;
  private:
  bool _internal_has_entityfiltername() const;
  public:
  void clear_entityfiltername();
  const std::string& entityfiltername() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_entityfiltername(ArgT0&& arg0, ArgT... args);
  std::string* mutable_entityfiltername();
  PROTOBUF_NODISCARD std::string* release_entityfiltername();
  void set_allocated_entityfiltername(std::string* entityfiltername);
  private:
  const std::string& _internal_entityfiltername() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_entityfiltername(const std::string& value);
  std::string* _internal_mutable_entityfiltername();
  public:

  // optional bytes spawngroupmanifest = 8;
  bool has_spawngroupmanifest() const;
  private:
  bool _internal_has_spawngroupmanifest() const;
  public:
  void clear_spawngroupmanifest();
  const std::string& spawngroupmanifest() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_spawngroupmanifest(ArgT0&& arg0, ArgT... args);
  std::string* mutable_spawngroupmanifest();
  PROTOBUF_NODISCARD std::string* release_spawngroupmanifest();
  void set_allocated_spawngroupmanifest(std::string* spawngroupmanifest);
  private:
  const std::string& _internal_spawngroupmanifest() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_spawngroupmanifest(const std::string& value);
  std::string* _internal_mutable_spawngroupmanifest();
  public:

  // optional string localnamefixup = 12;
  bool has_localnamefixup() const;
  private:
  bool _internal_has_localnamefixup() const;
  public:
  void clear_localnamefixup();
  const std::string& localnamefixup() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_localnamefixup(ArgT0&& arg0, ArgT... args);
  std::string* mutable_localnamefixup();
  PROTOBUF_NODISCARD std::string* release_localnamefixup();
  void set_allocated_localnamefixup(std::string* localnamefixup);
  private:
  const std::string& _internal_localnamefixup() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localnamefixup(const std::string& value);
  std::string* _internal_mutable_localnamefixup();
  public:

  // optional string parentnamefixup = 13;
  bool has_parentnamefixup() const;
  private:
  bool _internal_has_parentnamefixup() const;
  public:
  void clear_parentnamefixup();
  const std::string& parentnamefixup() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_parentnamefixup(ArgT0&& arg0, ArgT... args);
  std::string* mutable_parentnamefixup();
  PROTOBUF_NODISCARD std::string* release_parentnamefixup();
  void set_allocated_parentnamefixup(std::string* parentnamefixup);
  private:
  const std::string& _internal_parentnamefixup() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_parentnamefixup(const std::string& value);
  std::string* _internal_mutable_parentnamefixup();
  public:

  // optional string savegamefilename = 17;
  bool has_savegamefilename() const;
  private:
  bool _internal_has_savegamefilename() const;
  public:
  void clear_savegamefilename();
  const std::string& savegamefilename() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_savegamefilename(ArgT0&& arg0, ArgT... args);
  std::string* mutable_savegamefilename();
  PROTOBUF_NODISCARD std::string* release_savegamefilename();
  void set_allocated_savegamefilename(std::string* savegamefilename);
  private:
  const std::string& _internal_savegamefilename() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_savegamefilename(const std::string& value);
  std::string* _internal_mutable_savegamefilename();
  public:

  // optional string worldgroupname = 20;
  bool has_worldgroupname() const;
  private:
  bool _internal_has_worldgroupname() const;
  public:
  void clear_worldgroupname();
  const std::string& worldgroupname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_worldgroupname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_worldgroupname();
  PROTOBUF_NODISCARD std::string* release_worldgroupname();
  void set_allocated_worldgroupname(std::string* worldgroupname);
  private:
  const std::string& _internal_worldgroupname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_worldgroupname(const std::string& value);
  std::string* _internal_mutable_worldgroupname();
  public:

  // optional .CMsgVector world_offset_pos = 6;
  bool has_world_offset_pos() const;
  private:
  bool _internal_has_world_offset_pos() const;
  public:
  void clear_world_offset_pos();
  const ::CMsgVector& world_offset_pos() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_world_offset_pos();
  ::CMsgVector* mutable_world_offset_pos();
  void set_allocated_world_offset_pos(::CMsgVector* world_offset_pos);
  private:
  const ::CMsgVector& _internal_world_offset_pos() const;
  ::CMsgVector* _internal_mutable_world_offset_pos();
  public:
  void unsafe_arena_set_allocated_world_offset_pos(
      ::CMsgVector* world_offset_pos);
  ::CMsgVector* unsafe_arena_release_world_offset_pos();

  // optional .CMsgQAngle world_offset_angle = 7;
  bool has_world_offset_angle() const;
  private:
  bool _internal_has_world_offset_angle() const;
  public:
  void clear_world_offset_angle();
  const ::CMsgQAngle& world_offset_angle() const;
  PROTOBUF_NODISCARD ::CMsgQAngle* release_world_offset_angle();
  ::CMsgQAngle* mutable_world_offset_angle();
  void set_allocated_world_offset_angle(::CMsgQAngle* world_offset_angle);
  private:
  const ::CMsgQAngle& _internal_world_offset_angle() const;
  ::CMsgQAngle* _internal_mutable_world_offset_angle();
  public:
  void unsafe_arena_set_allocated_world_offset_angle(
      ::CMsgQAngle* world_offset_angle);
  ::CMsgQAngle* unsafe_arena_release_world_offset_angle();

  // optional uint32 spawngrouphandle = 4;
  bool has_spawngrouphandle() const;
  private:
  bool _internal_has_spawngrouphandle() const;
  public:
  void clear_spawngrouphandle();
  uint32_t spawngrouphandle() const;
  void set_spawngrouphandle(uint32_t value);
  private:
  uint32_t _internal_spawngrouphandle() const;
  void _internal_set_spawngrouphandle(uint32_t value);
  public:

  // optional uint32 spawngroupownerhandle = 5;
  bool has_spawngroupownerhandle() const;
  private:
  bool _internal_has_spawngroupownerhandle() const;
  public:
  void clear_spawngroupownerhandle();
  uint32_t spawngroupownerhandle() const;
  void set_spawngroupownerhandle(uint32_t value);
  private:
  uint32_t _internal_spawngroupownerhandle() const;
  void _internal_set_spawngroupownerhandle(uint32_t value);
  public:

  // optional uint32 flags = 9;
  bool has_flags() const;
  private:
  bool _internal_has_flags() const;
  public:
  void clear_flags();
  uint32_t flags() const;
  void set_flags(uint32_t value);
  private:
  uint32_t _internal_flags() const;
  void _internal_set_flags(uint32_t value);
  public:

  // optional int32 tickcount = 10;
  bool has_tickcount() const;
  private:
  bool _internal_has_tickcount() const;
  public:
  void clear_tickcount();
  int32_t tickcount() const;
  void set_tickcount(int32_t value);
  private:
  int32_t _internal_tickcount() const;
  void _internal_set_tickcount(int32_t value);
  public:

  // optional int32 manifestloadpriority = 14;
  bool has_manifestloadpriority() const;
  private:
  bool _internal_has_manifestloadpriority() const;
  public:
  void clear_manifestloadpriority();
  int32_t manifestloadpriority() const;
  void set_manifestloadpriority(int32_t value);
  private:
  int32_t _internal_manifestloadpriority() const;
  void _internal_set_manifestloadpriority(int32_t value);
  public:

  // optional uint32 worldgroupid = 15;
  bool has_worldgroupid() const;
  private:
  bool _internal_has_worldgroupid() const;
  public:
  void clear_worldgroupid();
  uint32_t worldgroupid() const;
  void set_worldgroupid(uint32_t value);
  private:
  uint32_t _internal_worldgroupid() const;
  void _internal_set_worldgroupid(uint32_t value);
  public:

  // optional bool manifestincomplete = 11;
  bool has_manifestincomplete() const;
  private:
  bool _internal_has_manifestincomplete() const;
  public:
  void clear_manifestincomplete();
  bool manifestincomplete() const;
  void set_manifestincomplete(bool value);
  private:
  bool _internal_manifestincomplete() const;
  void _internal_set_manifestincomplete(bool value);
  public:

  // optional bool leveltransition = 19;
  bool has_leveltransition() const;
  private:
  bool _internal_has_leveltransition() const;
  public:
  void clear_leveltransition();
  bool leveltransition() const;
  void set_leveltransition(bool value);
  private:
  bool _internal_leveltransition() const;
  void _internal_set_leveltransition(bool value);
  public:

  // optional uint32 creationsequence = 16;
  bool has_creationsequence() const;
  private:
  bool _internal_has_creationsequence() const;
  public:
  void clear_creationsequence();
  uint32_t creationsequence() const;
  void set_creationsequence(uint32_t value);
  private:
  uint32_t _internal_creationsequence() const;
  void _internal_set_creationsequence(uint32_t value);
  public:

  // optional uint32 spawngroupparenthandle = 18;
  bool has_spawngroupparenthandle() const;
  private:
  bool _internal_has_spawngroupparenthandle() const;
  public:
  void clear_spawngroupparenthandle();
  uint32_t spawngroupparenthandle() const;
  void set_spawngroupparenthandle(uint32_t value);
  private:
  uint32_t _internal_spawngroupparenthandle() const;
  void _internal_set_spawngroupparenthandle(uint32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr worldname_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entitylumpname_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entityfiltername_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr spawngroupmanifest_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localnamefixup_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr parentnamefixup_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr savegamefilename_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr worldgroupname_;
    ::CMsgVector* world_offset_pos_;
    ::CMsgQAngle* world_offset_angle_;
    uint32_t spawngrouphandle_;
    uint32_t spawngroupownerhandle_;
    uint32_t flags_;
    int32_t tickcount_;
    int32_t manifestloadpriority_;
    uint32_t worldgroupid_;
    bool manifestincomplete_;
    bool leveltransition_;
    uint32_t creationsequence_;
    uint32_t spawngroupparenthandle_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_networkbasetypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kSpawngroupmanifestFieldNumber = 2,
    kSpawngrouphandleFieldNumber = 1,
    kManifestincompleteFieldNumber = 3,
  };
  // optional bytes spawngroupmanifest = 2;
  bool has_spawngroupmanifest() const;
  private:
  bool _internal_has_spawngroupmanifest() const;
  public:
  void clear_spawngroupmanifest();
  const std::string& spawngroupmanifest() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_spawngroupmanifest(ArgT0&& arg0, ArgT... args);
  std::string* mutable_spawngroupmanifest();
  PROTOBUF_NODISCARD std::string* release_spawngroupmanifest();
  void set_allocated_spawngroupmanifest(std::string* spawngroupmanifest);
  private:
  const std::string& _internal_spawngroupmanifest() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_spawngroupmanifest(const std::string& value);
  std::string* _internal_mutable_spawngroupmanifest();
  public:

  // optional uint32 spawngrouphandle = 1;
  bool has_spawngrouphandle() const;
  private:
  bool _internal_has_spawngrouphandle() const;
  public:
  void clear_spawngrouphandle();
  uint32_t spawngrouphandle() const;
  void set_spawngrouphandle(uint32_t value);
  private:
  uint32_t _internal_spawngrouphandle() const;
  void _internal_set_spawngrouphandle(uint32_t value);
  public:

  // optional bool manifestincomplete = 3;
  bool has_manifestincomplete() const;
  private:
  bool _internal_has_manifestincomplete() const;
  public:
  void clear_manifestincomplete();
  bool manifestincomplete() const;
  void set_manifestincomplete(bool value);
  private:
  bool _internal_manifestincomplete() const;
  void _internal_set_manifestincomplete(bool value);
  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kSpawngrouphandleFieldNumber = 1,
    kTickcountFieldNumber = 2,
    kCreationsequenceFieldNumber = 3,
  };
  // optional uint32 spawngrouphandle = 1;
  bool has_spawngrouphandle() const;
  private:
  bool _internal_has_spawngrouphandle() const;
  public:
  void clear_spawngrouphandle();
  uint32_t spawngrouphandle() const;
  void set_spawngrouphandle(uint32_t value);
  private:
  uint32_t _internal_spawngrouphandle() const;
  void _internal_set_spawngrouphandle(uint32_t value);
  public:

  // optional int32 tickcount = 2;
  bool has_tickcount() const;
  private:
  bool _internal_has_tickcount() const;
  public:
  void clear_tickcount();
  int32_t tickcount() const;
  void set_tickcount(int32_t value);
  private:
  int32_t _internal_tickcount() const;
  void _internal_set_tickcount(int32_t value);
  public:

  // optional uint32 creationsequence = 3;
  bool has_creationsequence() const;
  private:
  bool _internal_has_creationsequence() const;
  public:
  void clear_creationsequence();
  uint32_t creationsequence() const;
  void set_creationsequence(uint32_t value);
  private:
  uint32_t _internal_creationsequence() const;
  void _internal_set_creationsequence(uint32_t value);
  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kSpawngrouphandleFieldNumber = 1,
    kFlagsFieldNumber = 2,
    kTickcountFieldNumber = 3,
  };
  // optional uint32 spawngrouphandle = 1;
  bool has_spawngrouphandle() const;
  private:
  bool _internal_has_spawngrouphandle() const;
  public:
  void clear_spawngrouphandle();
  uint32_t spawngrouphandle() const;
  void set_spawngrouphandle(uint32_t value);
  private:
  uint32_t _internal_spawngrouphandle() const;
  void _internal_set_spawngrouphandle(uint32_t value);
  public:

  // optional uint32 flags = 2;
  bool has_flags() const;
  private:
  bool _internal_has_flags() const;
  public:
  void clear_flags();
  uint32_t flags() const;
  void set_flags(uint32_t value);
  private:
  uint32_t _internal_flags() const;
  void _internal_set_flags(uint32_t value);
  public:

  // optional int32 tickcount = 3;
  bool has_tickcount() const;
  private:
  bool _internal_has_tickcount() const;
  public:
  void clear_tickcount();
  int32_t tickcount() const;
  void set_tickcount(int32_t value);
  private:
  int32_t _internal_tickcount() const;
  void _internal_set_tickcount(int32_t value);
  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kSpawngrouphandleFieldNumber = 1,
  };
  // optional uint32 spawngrouphandle = 1;
  bool has_spawngrouphandle() const;
  private:
  bool _internal_has_spawngrouphandle() const;
  public:
  void clear_spawngrouphandle();
  uint32_t spawngrouphandle() const;
  void set_spawngrouphandle(uint32_t value);
  private:
  uint32_t _internal_spawngrouphandle() const;
  void _internal_set_spawngrouphandle(uint32_t value);
  public:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kHostnameFieldNumber = 9,
    kSavegamenameFieldNumber = 10,
    kS1MapnameFieldNumber = 11,
    kGamemodeFieldNumber = 12,
    kServerIpAddressFieldNumber = 13,
    kDataFieldNumber = 14,
    kPreviouslevelFieldNumber = 17,
    kLandmarknameFieldNumber = 18,
    kIsMultiplayerFieldNumber = 1,
    kIsLoadsavegameFieldNumber = 2,
    kIsBackgroundMapFieldNumber = 3,
    kIsHeadlessFieldNumber = 4,
    kMinClientLimitFieldNumber = 5,
    kMaxClientLimitFieldNumber = 6,
    kMaxClientsFieldNumber = 7,
    kTickIntervalFieldNumber = 8,
    kIsLocalonlyFieldNumber = 15,
    kNoSteamServerFieldNumber = 19,
    kIsTransitionFieldNumber = 16,
  };
  // optional string hostname = 9;
  bool has_hostname() const;
  private:
  bool _internal_has_hostname() const;
  public:
  void clear_hostname();
  const std::string& hostname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_hostname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_hostname();
  PROTOBUF_NODISCARD std::string* release_hostname();
  void set_allocated_hostname(std::string* hostname);
  private:
  const std::string& _internal_hostname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hostname(const std::string& value);
  std::string* _internal_mutable_hostname();
  public:

  // optional string savegamename = 10;
  bool has_savegamename() const;
  private:
  bool _internal_has_savegamename() const;
  public:
  void clear_savegamename();
  const std::string& savegamename() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_savegamename(ArgT0&& arg0, ArgT... args);
  std::string* mutable_savegamename();
  PROTOBUF_NODISCARD std::string* release_savegamename();
  void set_allocated_savegamename(std::string* savegamename);
  private:
  const std::string& _internal_savegamename() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_savegamename(const std::string& value);
  std::string* _internal_mutable_savegamename();
  public:

  // optional string s1_mapname = 11;
  bool has_s1_mapname() const;
  private:
  bool _internal_has_s1_mapname() const;
  public:
  void clear_s1_mapname();
  const std::string& s1_mapname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_s1_mapname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_s1_mapname();
  PROTOBUF_NODISCARD std::string* release_s1_mapname();
  void set_allocated_s1_mapname(std::string* s1_mapname);
  private:
  const std::string& _internal_s1_mapname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_s1_mapname(const std::string& value);
  std::string* _internal_mutable_s1_mapname();
  public:

  // optional string gamemode = 12;
  bool has_gamemode() const;
  private:
  bool _internal_has_gamemode() const;
  public:
  void clear_gamemode();
  const std::string& gamemode() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_gamemode(ArgT0&& arg0, ArgT... args);
  std::string* mutable_gamemode();
  PROTOBUF_NODISCARD std::string* release_gamemode();
  void set_allocated_gamemode(std::string* gamemode);
  private:
  const std::string& _internal_gamemode() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_gamemode(const std::string& value);
  std::string* _internal_mutable_gamemode();
  public:

  // optional string server_ip_address = 13;
  bool has_server_ip_address() const;
  private:
  bool _internal_has_server_ip_address() const;
  public:
  void clear_server_ip_address();
  const std::string& server_ip_address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_server_ip_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_server_ip_address();
  PROTOBUF_NODISCARD std::string* release_server_ip_address();
  void set_allocated_server_ip_address(std::string* server_ip_address);
  private:
  const std::string& _internal_server_ip_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_server_ip_address(const std::string& value);
  std::string* _internal_mutable_server_ip_address();
  public:

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

  // optional string previouslevel = 17;
  bool has_previouslevel() const;
  private:
  bool _internal_has_previouslevel() const;
  public:
  void clear_previouslevel();
  const std::string& previouslevel() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_previouslevel(ArgT0&& arg0, ArgT... args);
  std::string* mutable_previouslevel();
  PROTOBUF_NODISCARD std::string* release_previouslevel();
  void set_allocated_previouslevel(std::string* previouslevel);
  private:
  const std::string& _internal_previouslevel() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_previouslevel(const std::string& value);
  std::string* _internal_mutable_previouslevel();
  public:

  // optional string landmarkname = 18;
  bool has_landmarkname() const;
  private:
  bool _internal_has_landmarkname() const;
  public:
  void clear_landmarkname();
  const std::string& landmarkname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_landmarkname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_landmarkname();
  PROTOBUF_NODISCARD std::string* release_landmarkname();
  void set_allocated_landmarkname(std::string* landmarkname);
  private:
  const std::string& _internal_landmarkname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_landmarkname(const std::string& value);
  std::string* _internal_mutable_landmarkname();
  public:

  // optional bool is_multiplayer = 1;
  bool has_is_multiplayer() const;
  private:
  bool _internal_has_is_multiplayer() const;
  public:
  void clear_is_multiplayer();
  bool is_multiplayer() const;
  void set_is_multiplayer(bool value);
  private:
  bool _internal_is_multiplayer() const;
  void _internal_set_is_multiplayer(bool value);
  public:

  // optional bool is_loadsavegame = 2;
  bool has_is_loadsavegame() const;
  private:
  bool _internal_has_is_loadsavegame() const;
  public:
  void clear_is_loadsavegame();
  bool is_loadsavegame() const;
  void set_is_loadsavegame(bool value);
  private:
  bool _internal_is_loadsavegame() const;
  void _internal_set_is_loadsavegame(bool value);
  public:

  // optional bool is_background_map = 3;
  bool has_is_background_map() const;
  private:
  bool _internal_has_is_background_map() const;
  public:
  void clear_is_background_map();
  bool is_background_map() const;
  void set_is_background_map(bool value);
  private:
  bool _internal_is_background_map() const;
  void _internal_set_is_background_map(bool value);
  public:

  // optional bool is_headless = 4;
  bool has_is_headless() const;
  private:
  bool _internal_has_is_headless() const;
  public:
  void clear_is_headless();
  bool is_headless() const;
  void set_is_headless(bool value);
  private:
  bool _internal_is_headless() const;
  void _internal_set_is_headless(bool value);
  public:

  // optional uint32 min_client_limit = 5;
  bool has_min_client_limit() const;
  private:
  bool _internal_has_min_client_limit() const;
  public:
  void clear_min_client_limit();
  uint32_t min_client_limit() const;
  void set_min_client_limit(uint32_t value);
  private:
  uint32_t _internal_min_client_limit() const;
  void _internal_set_min_client_limit(uint32_t value);
  public:

  // optional uint32 max_client_limit = 6;
  bool has_max_client_limit() const;
  private:
  bool _internal_has_max_client_limit() const;
  public:
  void clear_max_client_limit();
  uint32_t max_client_limit() const;
  void set_max_client_limit(uint32_t value);
  private:
  uint32_t _internal_max_client_limit() const;
  void _internal_set_max_client_limit(uint32_t value);
  public:

  // optional uint32 max_clients = 7;
  bool has_max_clients() const;
  private:
  bool _internal_has_max_clients() const;
  public:
  void clear_max_clients();
  uint32_t max_clients() const;
  void set_max_clients(uint32_t value);
  private:
  uint32_t _internal_max_clients() const;
  void _internal_set_max_clients(uint32_t value);
  public:

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

  // optional bool is_localonly = 15;
  bool has_is_localonly() const;
  private:
  bool _internal_has_is_localonly() const;
  public:
  void clear_is_localonly();
  bool is_localonly() const;
  void set_is_localonly(bool value);
  private:
  bool _internal_is_localonly() const;
  void _internal_set_is_localonly(bool value);
  public:

  // optional bool no_steam_server = 19;
  bool has_no_steam_server() const;
  private:
  bool _internal_has_no_steam_server() const;
  public:
  void clear_no_steam_server();
  bool no_steam_server() const;
  void set_no_steam_server(bool value);
  private:
  bool _internal_no_steam_server() const;
  void _internal_set_no_steam_server(bool value);
  public:

  // optional bool is_transition = 16;
  bool has_is_transition() const;
  private:
  bool _internal_has_is_transition() const;
  public:
  void clear_is_transition();
  bool is_transition() const;
  void set_is_transition(bool value);
  private:
  bool _internal_is_transition() const;
  void _internal_set_is_transition(bool value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hostname_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr savegamename_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr s1_mapname_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gamemode_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr server_ip_address_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr previouslevel_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr landmarkname_;
    bool is_multiplayer_;
    bool is_loadsavegame_;
    bool is_background_map_;
    bool is_headless_;
    uint32_t min_client_limit_;
    uint32_t max_client_limit_;
    uint32_t max_clients_;
    uint32_t tick_interval_;
    bool is_localonly_;
    bool no_steam_server_;
    bool is_transition_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_networkbasetypes_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  enum : int {
    kVectorsFieldNumber = 2,
    kColorsFieldNumber = 3,
    kDimensionsFieldNumber = 4,
    kTimesFieldNumber = 5,
    kBoolsFieldNumber = 6,
    kUint64SFieldNumber = 7,
    kStringsFieldNumber = 8,
    kEtypeFieldNumber = 1,
  };
  // repeated .CMsgVector vectors = 2;
  int vectors_size() const;
  private:
  int _internal_vectors_size() const;
  public:
  void clear_vectors();
  ::CMsgVector* mutable_vectors(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgVector >*
      mutable_vectors();
  private:
  const ::CMsgVector& _internal_vectors(int index) const;
  ::CMsgVector* _internal_add_vectors();
  public:
  const ::CMsgVector& vectors(int index) const;
  ::CMsgVector* add_vectors();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgVector >&
      vectors() const;

  // repeated .CMsgRGBA colors = 3;
  int colors_size() const;
  private:
  int _internal_colors_size() const;
  public:
  void clear_colors();
  ::CMsgRGBA* mutable_colors(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgRGBA >*
      mutable_colors();
  private:
  const ::CMsgRGBA& _internal_colors(int index) const;
  ::CMsgRGBA* _internal_add_colors();
  public:
  const ::CMsgRGBA& colors(int index) const;
  ::CMsgRGBA* add_colors();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgRGBA >&
      colors() const;

  // repeated float dimensions = 4;
  int dimensions_size() const;
  private:
  int _internal_dimensions_size() const;
  public:
  void clear_dimensions();
  private:
  float _internal_dimensions(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_dimensions() const;
  void _internal_add_dimensions(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_dimensions();
  public:
  float dimensions(int index) const;
  void set_dimensions(int index, float value);
  void add_dimensions(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      dimensions() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_dimensions();

  // repeated float times = 5;
  int times_size() const;
  private:
  int _internal_times_size() const;
  public:
  void clear_times();
  private:
  float _internal_times(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_times() const;
  void _internal_add_times(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_times();
  public:
  float times(int index) const;
  void set_times(int index, float value);
  void add_times(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      times() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_times();

  // repeated bool bools = 6;
  int bools_size() const;
  private:
  int _internal_bools_size() const;
  public:
  void clear_bools();
  private:
  bool _internal_bools(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      _internal_bools() const;
  void _internal_add_bools(bool value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      _internal_mutable_bools();
  public:
  bool bools(int index) const;
  void set_bools(int index, bool value);
  void add_bools(bool value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      bools() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      mutable_bools();

  // repeated uint64 uint64s = 7;
  int uint64s_size() const;
  private:
  int _internal_uint64s_size() const;
  public:
  void clear_uint64s();
  private:
  uint64_t _internal_uint64s(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      _internal_uint64s() const;
  void _internal_add_uint64s(uint64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      _internal_mutable_uint64s();
  public:
  uint64_t uint64s(int index) const;
  void set_uint64s(int index, uint64_t value);
  void add_uint64s(uint64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      uint64s() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      mutable_uint64s();

  // repeated string strings = 8;
  int strings_size() const;
  private:
  int _internal_strings_size() const;
  public:
  void clear_strings();
  const std::string& strings(int index) const;
  std::string* mutable_strings(int index);
  void set_strings(int index, const std::string& value);
  void set_strings(int index, std::string&& value);
  void set_strings(int index, const char* value);
  void set_strings(int index, const char* value, size_t size);
  std::string* add_strings();
  void add_strings(const std::string& value);
  void add_strings(std::string&& value);
  void add_strings(const char* value);
  void add_strings(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& strings() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_strings();
  private:
  const std::string& _internal_strings(int index) const;
  std::string* _internal_add_strings();
  public:

  // optional int32 etype = 1;
  bool has_etype() const;
  private:
  bool _internal_has_etype() const;
  public:
  void clear_etype();
  int32_t etype() const;
  void set_etype(int32_t value);
  private:
  int32_t _internal_etype() const;
  void _internal_set_etype(int32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgVector > vectors_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgRGBA > colors_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > dimensions_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > times_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > bools_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > uint64s_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> strings_;
    int32_t etype_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_networkbasetypes_2eproto;
};
// ===================================================================

static const int kMaximumSizeBytesFieldNumber = 50000;
extern ::PROTOBUF_NAMESPACE_ID::internal::ExtensionIdentifier< ::PROTOBUF_NAMESPACE_ID::MessageOptions,
    ::PROTOBUF_NAMESPACE_ID::internal::PrimitiveTypeTraits< int32_t >, 5, false >
  maximum_size_bytes;

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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// CMsgVector

// optional float x = 1;
inline bool CMsgVector::_internal_has_x() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgVector::has_x() const {
  return _internal_has_x();
}
inline void CMsgVector::clear_x() {
  _impl_.x_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float CMsgVector::_internal_x() const {
  return _impl_.x_;
}
inline float CMsgVector::x() const {
  // @@protoc_insertion_point(field_get:CMsgVector.x)
  return _internal_x();
}
inline void CMsgVector::_internal_set_x(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.x_ = value;
}
inline void CMsgVector::set_x(float value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:CMsgVector.x)
}

// optional float y = 2;
inline bool CMsgVector::_internal_has_y() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgVector::has_y() const {
  return _internal_has_y();
}
inline void CMsgVector::clear_y() {
  _impl_.y_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CMsgVector::_internal_y() const {
  return _impl_.y_;
}
inline float CMsgVector::y() const {
  // @@protoc_insertion_point(field_get:CMsgVector.y)
  return _internal_y();
}
inline void CMsgVector::_internal_set_y(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.y_ = value;
}
inline void CMsgVector::set_y(float value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:CMsgVector.y)
}

// optional float z = 3;
inline bool CMsgVector::_internal_has_z() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgVector::has_z() const {
  return _internal_has_z();
}
inline void CMsgVector::clear_z() {
  _impl_.z_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CMsgVector::_internal_z() const {
  return _impl_.z_;
}
inline float CMsgVector::z() const {
  // @@protoc_insertion_point(field_get:CMsgVector.z)
  return _internal_z();
}
inline void CMsgVector::_internal_set_z(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.z_ = value;
}
inline void CMsgVector::set_z(float value) {
  _internal_set_z(value);
  // @@protoc_insertion_point(field_set:CMsgVector.z)
}

// optional float w = 4;
inline bool CMsgVector::_internal_has_w() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgVector::has_w() const {
  return _internal_has_w();
}
inline void CMsgVector::clear_w() {
  _impl_.w_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float CMsgVector::_internal_w() const {
  return _impl_.w_;
}
inline float CMsgVector::w() const {
  // @@protoc_insertion_point(field_get:CMsgVector.w)
  return _internal_w();
}
inline void CMsgVector::_internal_set_w(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.w_ = value;
}
inline void CMsgVector::set_w(float value) {
  _internal_set_w(value);
  // @@protoc_insertion_point(field_set:CMsgVector.w)
}

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

// CMsgVector2D

// optional float x = 1;
inline bool CMsgVector2D::_internal_has_x() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgVector2D::has_x() const {
  return _internal_has_x();
}
inline void CMsgVector2D::clear_x() {
  _impl_.x_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float CMsgVector2D::_internal_x() const {
  return _impl_.x_;
}
inline float CMsgVector2D::x() const {
  // @@protoc_insertion_point(field_get:CMsgVector2D.x)
  return _internal_x();
}
inline void CMsgVector2D::_internal_set_x(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.x_ = value;
}
inline void CMsgVector2D::set_x(float value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:CMsgVector2D.x)
}

// optional float y = 2;
inline bool CMsgVector2D::_internal_has_y() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgVector2D::has_y() const {
  return _internal_has_y();
}
inline void CMsgVector2D::clear_y() {
  _impl_.y_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CMsgVector2D::_internal_y() const {
  return _impl_.y_;
}
inline float CMsgVector2D::y() const {
  // @@protoc_insertion_point(field_get:CMsgVector2D.y)
  return _internal_y();
}
inline void CMsgVector2D::_internal_set_y(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.y_ = value;
}
inline void CMsgVector2D::set_y(float value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:CMsgVector2D.y)
}

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

// CMsgQAngle

// optional float x = 1;
inline bool CMsgQAngle::_internal_has_x() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgQAngle::has_x() const {
  return _internal_has_x();
}
inline void CMsgQAngle::clear_x() {
  _impl_.x_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float CMsgQAngle::_internal_x() const {
  return _impl_.x_;
}
inline float CMsgQAngle::x() const {
  // @@protoc_insertion_point(field_get:CMsgQAngle.x)
  return _internal_x();
}
inline void CMsgQAngle::_internal_set_x(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.x_ = value;
}
inline void CMsgQAngle::set_x(float value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:CMsgQAngle.x)
}

// optional float y = 2;
inline bool CMsgQAngle::_internal_has_y() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgQAngle::has_y() const {
  return _internal_has_y();
}
inline void CMsgQAngle::clear_y() {
  _impl_.y_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CMsgQAngle::_internal_y() const {
  return _impl_.y_;
}
inline float CMsgQAngle::y() const {
  // @@protoc_insertion_point(field_get:CMsgQAngle.y)
  return _internal_y();
}
inline void CMsgQAngle::_internal_set_y(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.y_ = value;
}
inline void CMsgQAngle::set_y(float value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:CMsgQAngle.y)
}

// optional float z = 3;
inline bool CMsgQAngle::_internal_has_z() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgQAngle::has_z() const {
  return _internal_has_z();
}
inline void CMsgQAngle::clear_z() {
  _impl_.z_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CMsgQAngle::_internal_z() const {
  return _impl_.z_;
}
inline float CMsgQAngle::z() const {
  // @@protoc_insertion_point(field_get:CMsgQAngle.z)
  return _internal_z();
}
inline void CMsgQAngle::_internal_set_z(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.z_ = value;
}
inline void CMsgQAngle::set_z(float value) {
  _internal_set_z(value);
  // @@protoc_insertion_point(field_set:CMsgQAngle.z)
}

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

// CMsgQuaternion

// optional float x = 1;
inline bool CMsgQuaternion::_internal_has_x() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgQuaternion::has_x() const {
  return _internal_has_x();
}
inline void CMsgQuaternion::clear_x() {
  _impl_.x_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline float CMsgQuaternion::_internal_x() const {
  return _impl_.x_;
}
inline float CMsgQuaternion::x() const {
  // @@protoc_insertion_point(field_get:CMsgQuaternion.x)
  return _internal_x();
}
inline void CMsgQuaternion::_internal_set_x(float value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.x_ = value;
}
inline void CMsgQuaternion::set_x(float value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:CMsgQuaternion.x)
}

// optional float y = 2;
inline bool CMsgQuaternion::_internal_has_y() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgQuaternion::has_y() const {
  return _internal_has_y();
}
inline void CMsgQuaternion::clear_y() {
  _impl_.y_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float CMsgQuaternion::_internal_y() const {
  return _impl_.y_;
}
inline float CMsgQuaternion::y() const {
  // @@protoc_insertion_point(field_get:CMsgQuaternion.y)
  return _internal_y();
}
inline void CMsgQuaternion::_internal_set_y(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.y_ = value;
}
inline void CMsgQuaternion::set_y(float value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:CMsgQuaternion.y)
}

// optional float z = 3;
inline bool CMsgQuaternion::_internal_has_z() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgQuaternion::has_z() const {
  return _internal_has_z();
}
inline void CMsgQuaternion::clear_z() {
  _impl_.z_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CMsgQuaternion::_internal_z() const {
  return _impl_.z_;
}
inline float CMsgQuaternion::z() const {
  // @@protoc_insertion_point(field_get:CMsgQuaternion.z)
  return _internal_z();
}
inline void CMsgQuaternion::_internal_set_z(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.z_ = value;
}
inline void CMsgQuaternion::set_z(float value) {
  _internal_set_z(value);
  // @@protoc_insertion_point(field_set:CMsgQuaternion.z)
}

// optional float w = 4;
inline bool CMsgQuaternion::_internal_has_w() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgQuaternion::has_w() const {
  return _internal_has_w();
}
inline void CMsgQuaternion::clear_w() {
  _impl_.w_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float CMsgQuaternion::_internal_w() const {
  return _impl_.w_;
}
inline float CMsgQuaternion::w() const {
  // @@protoc_insertion_point(field_get:CMsgQuaternion.w)
  return _internal_w();
}
inline void CMsgQuaternion::_internal_set_w(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.w_ = value;
}
inline void CMsgQuaternion::set_w(float value) {
  _internal_set_w(value);
  // @@protoc_insertion_point(field_set:CMsgQuaternion.w)
}

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

// CMsgTransform

// optional .CMsgVector position = 1;
inline bool CMsgTransform::_internal_has_position() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr);
  return value;
}
inline bool CMsgTransform::has_position() const {
  return _internal_has_position();
}
inline void CMsgTransform::clear_position() {
  if (_impl_.position_ != nullptr) _impl_.position_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsgVector& CMsgTransform::_internal_position() const {
  const ::CMsgVector* p = _impl_.position_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTransform::position() const {
  // @@protoc_insertion_point(field_get:CMsgTransform.position)
  return _internal_position();
}
inline void CMsgTransform::unsafe_arena_set_allocated_position(
    ::CMsgVector* position) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.position_);
  }
  _impl_.position_ = position;
  if (position) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTransform.position)
}
inline ::CMsgVector* CMsgTransform::release_position() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.position_;
  _impl_.position_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTransform::unsafe_arena_release_position() {
  // @@protoc_insertion_point(field_release:CMsgTransform.position)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.position_;
  _impl_.position_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTransform::_internal_mutable_position() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.position_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.position_ = p;
  }
  return _impl_.position_;
}
inline ::CMsgVector* CMsgTransform::mutable_position() {
  ::CMsgVector* _msg = _internal_mutable_position();
  // @@protoc_insertion_point(field_mutable:CMsgTransform.position)
  return _msg;
}
inline void CMsgTransform::set_allocated_position(::CMsgVector* position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.position_;
  }
  if (position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(position);
    if (message_arena != submessage_arena) {
      position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, position, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.position_ = position;
  // @@protoc_insertion_point(field_set_allocated:CMsgTransform.position)
}

// optional float scale = 2;
inline bool CMsgTransform::_internal_has_scale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgTransform::has_scale() const {
  return _internal_has_scale();
}
inline void CMsgTransform::clear_scale() {
  _impl_.scale_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CMsgTransform::_internal_scale() const {
  return _impl_.scale_;
}
inline float CMsgTransform::scale() const {
  // @@protoc_insertion_point(field_get:CMsgTransform.scale)
  return _internal_scale();
}
inline void CMsgTransform::_internal_set_scale(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.scale_ = value;
}
inline void CMsgTransform::set_scale(float value) {
  _internal_set_scale(value);
  // @@protoc_insertion_point(field_set:CMsgTransform.scale)
}

// optional .CMsgQuaternion orientation = 3;
inline bool CMsgTransform::_internal_has_orientation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.orientation_ != nullptr);
  return value;
}
inline bool CMsgTransform::has_orientation() const {
  return _internal_has_orientation();
}
inline void CMsgTransform::clear_orientation() {
  if (_impl_.orientation_ != nullptr) _impl_.orientation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::CMsgQuaternion& CMsgTransform::_internal_orientation() const {
  const ::CMsgQuaternion* p = _impl_.orientation_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQuaternion&>(
      ::_CMsgQuaternion_default_instance_);
}
inline const ::CMsgQuaternion& CMsgTransform::orientation() const {
  // @@protoc_insertion_point(field_get:CMsgTransform.orientation)
  return _internal_orientation();
}
inline void CMsgTransform::unsafe_arena_set_allocated_orientation(
    ::CMsgQuaternion* orientation) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.orientation_);
  }
  _impl_.orientation_ = orientation;
  if (orientation) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTransform.orientation)
}
inline ::CMsgQuaternion* CMsgTransform::release_orientation() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgQuaternion* temp = _impl_.orientation_;
  _impl_.orientation_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgQuaternion* CMsgTransform::unsafe_arena_release_orientation() {
  // @@protoc_insertion_point(field_release:CMsgTransform.orientation)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgQuaternion* temp = _impl_.orientation_;
  _impl_.orientation_ = nullptr;
  return temp;
}
inline ::CMsgQuaternion* CMsgTransform::_internal_mutable_orientation() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.orientation_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgQuaternion>(GetArenaForAllocation());
    _impl_.orientation_ = p;
  }
  return _impl_.orientation_;
}
inline ::CMsgQuaternion* CMsgTransform::mutable_orientation() {
  ::CMsgQuaternion* _msg = _internal_mutable_orientation();
  // @@protoc_insertion_point(field_mutable:CMsgTransform.orientation)
  return _msg;
}
inline void CMsgTransform::set_allocated_orientation(::CMsgQuaternion* orientation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.orientation_;
  }
  if (orientation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(orientation);
    if (message_arena != submessage_arena) {
      orientation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, orientation, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.orientation_ = orientation;
  // @@protoc_insertion_point(field_set_allocated:CMsgTransform.orientation)
}

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

// CMsgRGBA

// optional int32 r = 1;
inline bool CMsgRGBA::_internal_has_r() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgRGBA::has_r() const {
  return _internal_has_r();
}
inline void CMsgRGBA::clear_r() {
  _impl_.r_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CMsgRGBA::_internal_r() const {
  return _impl_.r_;
}
inline int32_t CMsgRGBA::r() const {
  // @@protoc_insertion_point(field_get:CMsgRGBA.r)
  return _internal_r();
}
inline void CMsgRGBA::_internal_set_r(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.r_ = value;
}
inline void CMsgRGBA::set_r(int32_t value) {
  _internal_set_r(value);
  // @@protoc_insertion_point(field_set:CMsgRGBA.r)
}

// optional int32 g = 2;
inline bool CMsgRGBA::_internal_has_g() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgRGBA::has_g() const {
  return _internal_has_g();
}
inline void CMsgRGBA::clear_g() {
  _impl_.g_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CMsgRGBA::_internal_g() const {
  return _impl_.g_;
}
inline int32_t CMsgRGBA::g() const {
  // @@protoc_insertion_point(field_get:CMsgRGBA.g)
  return _internal_g();
}
inline void CMsgRGBA::_internal_set_g(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.g_ = value;
}
inline void CMsgRGBA::set_g(int32_t value) {
  _internal_set_g(value);
  // @@protoc_insertion_point(field_set:CMsgRGBA.g)
}

// optional int32 b = 3;
inline bool CMsgRGBA::_internal_has_b() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgRGBA::has_b() const {
  return _internal_has_b();
}
inline void CMsgRGBA::clear_b() {
  _impl_.b_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CMsgRGBA::_internal_b() const {
  return _impl_.b_;
}
inline int32_t CMsgRGBA::b() const {
  // @@protoc_insertion_point(field_get:CMsgRGBA.b)
  return _internal_b();
}
inline void CMsgRGBA::_internal_set_b(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.b_ = value;
}
inline void CMsgRGBA::set_b(int32_t value) {
  _internal_set_b(value);
  // @@protoc_insertion_point(field_set:CMsgRGBA.b)
}

// optional int32 a = 4;
inline bool CMsgRGBA::_internal_has_a() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgRGBA::has_a() const {
  return _internal_has_a();
}
inline void CMsgRGBA::clear_a() {
  _impl_.a_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CMsgRGBA::_internal_a() const {
  return _impl_.a_;
}
inline int32_t CMsgRGBA::a() const {
  // @@protoc_insertion_point(field_get:CMsgRGBA.a)
  return _internal_a();
}
inline void CMsgRGBA::_internal_set_a(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.a_ = value;
}
inline void CMsgRGBA::set_a(int32_t value) {
  _internal_set_a(value);
  // @@protoc_insertion_point(field_set:CMsgRGBA.a)
}

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

// CMsgPlayerInfo

// optional string name = 1;
inline bool CMsgPlayerInfo::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgPlayerInfo::has_name() const {
  return _internal_has_name();
}
inline void CMsgPlayerInfo::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgPlayerInfo::name() const {
  // @@protoc_insertion_point(field_get:CMsgPlayerInfo.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgPlayerInfo::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgPlayerInfo.name)
}
inline std::string* CMsgPlayerInfo::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:CMsgPlayerInfo.name)
  return _s;
}
inline const std::string& CMsgPlayerInfo::_internal_name() const {
  return _impl_.name_.Get();
}
inline void CMsgPlayerInfo::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgPlayerInfo::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgPlayerInfo::release_name() {
  // @@protoc_insertion_point(field_release:CMsgPlayerInfo.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgPlayerInfo::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgPlayerInfo.name)
}

// optional fixed64 xuid = 2;
inline bool CMsgPlayerInfo::_internal_has_xuid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgPlayerInfo::has_xuid() const {
  return _internal_has_xuid();
}
inline void CMsgPlayerInfo::clear_xuid() {
  _impl_.xuid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgPlayerInfo::_internal_xuid() const {
  return _impl_.xuid_;
}
inline uint64_t CMsgPlayerInfo::xuid() const {
  // @@protoc_insertion_point(field_get:CMsgPlayerInfo.xuid)
  return _internal_xuid();
}
inline void CMsgPlayerInfo::_internal_set_xuid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.xuid_ = value;
}
inline void CMsgPlayerInfo::set_xuid(uint64_t value) {
  _internal_set_xuid(value);
  // @@protoc_insertion_point(field_set:CMsgPlayerInfo.xuid)
}

// optional int32 userid = 3;
inline bool CMsgPlayerInfo::_internal_has_userid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgPlayerInfo::has_userid() const {
  return _internal_has_userid();
}
inline void CMsgPlayerInfo::clear_userid() {
  _impl_.userid_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CMsgPlayerInfo::_internal_userid() const {
  return _impl_.userid_;
}
inline int32_t CMsgPlayerInfo::userid() const {
  // @@protoc_insertion_point(field_get:CMsgPlayerInfo.userid)
  return _internal_userid();
}
inline void CMsgPlayerInfo::_internal_set_userid(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.userid_ = value;
}
inline void CMsgPlayerInfo::set_userid(int32_t value) {
  _internal_set_userid(value);
  // @@protoc_insertion_point(field_set:CMsgPlayerInfo.userid)
}

// optional fixed64 steamid = 4;
inline bool CMsgPlayerInfo::_internal_has_steamid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgPlayerInfo::has_steamid() const {
  return _internal_has_steamid();
}
inline void CMsgPlayerInfo::clear_steamid() {
  _impl_.steamid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CMsgPlayerInfo::_internal_steamid() const {
  return _impl_.steamid_;
}
inline uint64_t CMsgPlayerInfo::steamid() const {
  // @@protoc_insertion_point(field_get:CMsgPlayerInfo.steamid)
  return _internal_steamid();
}
inline void CMsgPlayerInfo::_internal_set_steamid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.steamid_ = value;
}
inline void CMsgPlayerInfo::set_steamid(uint64_t value) {
  _internal_set_steamid(value);
  // @@protoc_insertion_point(field_set:CMsgPlayerInfo.steamid)
}

// optional bool fakeplayer = 5;
inline bool CMsgPlayerInfo::_internal_has_fakeplayer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgPlayerInfo::has_fakeplayer() const {
  return _internal_has_fakeplayer();
}
inline void CMsgPlayerInfo::clear_fakeplayer() {
  _impl_.fakeplayer_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool CMsgPlayerInfo::_internal_fakeplayer() const {
  return _impl_.fakeplayer_;
}
inline bool CMsgPlayerInfo::fakeplayer() const {
  // @@protoc_insertion_point(field_get:CMsgPlayerInfo.fakeplayer)
  return _internal_fakeplayer();
}
inline void CMsgPlayerInfo::_internal_set_fakeplayer(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.fakeplayer_ = value;
}
inline void CMsgPlayerInfo::set_fakeplayer(bool value) {
  _internal_set_fakeplayer(value);
  // @@protoc_insertion_point(field_set:CMsgPlayerInfo.fakeplayer)
}

// optional bool ishltv = 6;
inline bool CMsgPlayerInfo::_internal_has_ishltv() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgPlayerInfo::has_ishltv() const {
  return _internal_has_ishltv();
}
inline void CMsgPlayerInfo::clear_ishltv() {
  _impl_.ishltv_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool CMsgPlayerInfo::_internal_ishltv() const {
  return _impl_.ishltv_;
}
inline bool CMsgPlayerInfo::ishltv() const {
  // @@protoc_insertion_point(field_get:CMsgPlayerInfo.ishltv)
  return _internal_ishltv();
}
inline void CMsgPlayerInfo::_internal_set_ishltv(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.ishltv_ = value;
}
inline void CMsgPlayerInfo::set_ishltv(bool value) {
  _internal_set_ishltv(value);
  // @@protoc_insertion_point(field_set:CMsgPlayerInfo.ishltv)
}

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

// CEntityMsg

// optional uint32 target_entity = 1 [default = 16777215];
inline bool CEntityMsg::_internal_has_target_entity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CEntityMsg::has_target_entity() const {
  return _internal_has_target_entity();
}
inline void CEntityMsg::clear_target_entity() {
  _impl_.target_entity_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CEntityMsg::_internal_target_entity() const {
  return _impl_.target_entity_;
}
inline uint32_t CEntityMsg::target_entity() const {
  // @@protoc_insertion_point(field_get:CEntityMsg.target_entity)
  return _internal_target_entity();
}
inline void CEntityMsg::_internal_set_target_entity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.target_entity_ = value;
}
inline void CEntityMsg::set_target_entity(uint32_t value) {
  _internal_set_target_entity(value);
  // @@protoc_insertion_point(field_set:CEntityMsg.target_entity)
}

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

// CMsg_CVars_CVar

// optional string name = 1;
inline bool CMsg_CVars_CVar::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsg_CVars_CVar::has_name() const {
  return _internal_has_name();
}
inline void CMsg_CVars_CVar::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsg_CVars_CVar::name() const {
  // @@protoc_insertion_point(field_get:CMsg_CVars.CVar.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsg_CVars_CVar::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsg_CVars.CVar.name)
}
inline std::string* CMsg_CVars_CVar::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:CMsg_CVars.CVar.name)
  return _s;
}
inline const std::string& CMsg_CVars_CVar::_internal_name() const {
  return _impl_.name_.Get();
}
inline void CMsg_CVars_CVar::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsg_CVars_CVar::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsg_CVars_CVar::release_name() {
  // @@protoc_insertion_point(field_release:CMsg_CVars.CVar.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsg_CVars_CVar::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsg_CVars.CVar.name)
}

// optional string value = 2;
inline bool CMsg_CVars_CVar::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsg_CVars_CVar::has_value() const {
  return _internal_has_value();
}
inline void CMsg_CVars_CVar::clear_value() {
  _impl_.value_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsg_CVars_CVar::value() const {
  // @@protoc_insertion_point(field_get:CMsg_CVars.CVar.value)
  return _internal_value();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsg_CVars_CVar::set_value(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsg_CVars.CVar.value)
}
inline std::string* CMsg_CVars_CVar::mutable_value() {
  std::string* _s = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:CMsg_CVars.CVar.value)
  return _s;
}
inline const std::string& CMsg_CVars_CVar::_internal_value() const {
  return _impl_.value_.Get();
}
inline void CMsg_CVars_CVar::_internal_set_value(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.value_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsg_CVars_CVar::_internal_mutable_value() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.value_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsg_CVars_CVar::release_value() {
  // @@protoc_insertion_point(field_release:CMsg_CVars.CVar.value)
  if (!_internal_has_value()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.value_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsg_CVars_CVar::set_allocated_value(std::string* value) {
  if (value != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.value_.SetAllocated(value, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.value_.IsDefault()) {
    _impl_.value_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsg_CVars.CVar.value)
}

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

// CMsg_CVars

// repeated .CMsg_CVars.CVar cvars = 1;
inline int CMsg_CVars::_internal_cvars_size() const {
  return _impl_.cvars_.size();
}
inline int CMsg_CVars::cvars_size() const {
  return _internal_cvars_size();
}
inline void CMsg_CVars::clear_cvars() {
  _impl_.cvars_.Clear();
}
inline ::CMsg_CVars_CVar* CMsg_CVars::mutable_cvars(int index) {
  // @@protoc_insertion_point(field_mutable:CMsg_CVars.cvars)
  return _impl_.cvars_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsg_CVars_CVar >*
CMsg_CVars::mutable_cvars() {
  // @@protoc_insertion_point(field_mutable_list:CMsg_CVars.cvars)
  return &_impl_.cvars_;
}
inline const ::CMsg_CVars_CVar& CMsg_CVars::_internal_cvars(int index) const {
  return _impl_.cvars_.Get(index);
}
inline const ::CMsg_CVars_CVar& CMsg_CVars::cvars(int index) const {
  // @@protoc_insertion_point(field_get:CMsg_CVars.cvars)
  return _internal_cvars(index);
}
inline ::CMsg_CVars_CVar* CMsg_CVars::_internal_add_cvars() {
  return _impl_.cvars_.Add();
}
inline ::CMsg_CVars_CVar* CMsg_CVars::add_cvars() {
  ::CMsg_CVars_CVar* _add = _internal_add_cvars();
  // @@protoc_insertion_point(field_add:CMsg_CVars.cvars)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsg_CVars_CVar >&
CMsg_CVars::cvars() const {
  // @@protoc_insertion_point(field_list:CMsg_CVars.cvars)
  return _impl_.cvars_;
}

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

// CNETMsg_NOP

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

// CNETMsg_SplitScreenUser

// optional int32 slot = 1;
inline bool CNETMsg_SplitScreenUser::_internal_has_slot() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CNETMsg_SplitScreenUser::has_slot() const {
  return _internal_has_slot();
}
inline void CNETMsg_SplitScreenUser::clear_slot() {
  _impl_.slot_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CNETMsg_SplitScreenUser::_internal_slot() const {
  return _impl_.slot_;
}
inline int32_t CNETMsg_SplitScreenUser::slot() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SplitScreenUser.slot)
  return _internal_slot();
}
inline void CNETMsg_SplitScreenUser::_internal_set_slot(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.slot_ = value;
}
inline void CNETMsg_SplitScreenUser::set_slot(int32_t value) {
  _internal_set_slot(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SplitScreenUser.slot)
}

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

// CNETMsg_Tick

// optional uint32 tick = 1;
inline bool CNETMsg_Tick::_internal_has_tick() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CNETMsg_Tick::has_tick() const {
  return _internal_has_tick();
}
inline void CNETMsg_Tick::clear_tick() {
  _impl_.tick_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CNETMsg_Tick::_internal_tick() const {
  return _impl_.tick_;
}
inline uint32_t CNETMsg_Tick::tick() const {
  // @@protoc_insertion_point(field_get:CNETMsg_Tick.tick)
  return _internal_tick();
}
inline void CNETMsg_Tick::_internal_set_tick(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.tick_ = value;
}
inline void CNETMsg_Tick::set_tick(uint32_t value) {
  _internal_set_tick(value);
  // @@protoc_insertion_point(field_set:CNETMsg_Tick.tick)
}

// optional uint32 host_computationtime = 4;
inline bool CNETMsg_Tick::_internal_has_host_computationtime() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CNETMsg_Tick::has_host_computationtime() const {
  return _internal_has_host_computationtime();
}
inline void CNETMsg_Tick::clear_host_computationtime() {
  _impl_.host_computationtime_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CNETMsg_Tick::_internal_host_computationtime() const {
  return _impl_.host_computationtime_;
}
inline uint32_t CNETMsg_Tick::host_computationtime() const {
  // @@protoc_insertion_point(field_get:CNETMsg_Tick.host_computationtime)
  return _internal_host_computationtime();
}
inline void CNETMsg_Tick::_internal_set_host_computationtime(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.host_computationtime_ = value;
}
inline void CNETMsg_Tick::set_host_computationtime(uint32_t value) {
  _internal_set_host_computationtime(value);
  // @@protoc_insertion_point(field_set:CNETMsg_Tick.host_computationtime)
}

// optional uint32 host_computationtime_std_deviation = 5;
inline bool CNETMsg_Tick::_internal_has_host_computationtime_std_deviation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CNETMsg_Tick::has_host_computationtime_std_deviation() const {
  return _internal_has_host_computationtime_std_deviation();
}
inline void CNETMsg_Tick::clear_host_computationtime_std_deviation() {
  _impl_.host_computationtime_std_deviation_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CNETMsg_Tick::_internal_host_computationtime_std_deviation() const {
  return _impl_.host_computationtime_std_deviation_;
}
inline uint32_t CNETMsg_Tick::host_computationtime_std_deviation() const {
  // @@protoc_insertion_point(field_get:CNETMsg_Tick.host_computationtime_std_deviation)
  return _internal_host_computationtime_std_deviation();
}
inline void CNETMsg_Tick::_internal_set_host_computationtime_std_deviation(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.host_computationtime_std_deviation_ = value;
}
inline void CNETMsg_Tick::set_host_computationtime_std_deviation(uint32_t value) {
  _internal_set_host_computationtime_std_deviation(value);
  // @@protoc_insertion_point(field_set:CNETMsg_Tick.host_computationtime_std_deviation)
}

// optional uint32 legacy_host_loss = 7;
inline bool CNETMsg_Tick::_internal_has_legacy_host_loss() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CNETMsg_Tick::has_legacy_host_loss() const {
  return _internal_has_legacy_host_loss();
}
inline void CNETMsg_Tick::clear_legacy_host_loss() {
  _impl_.legacy_host_loss_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CNETMsg_Tick::_internal_legacy_host_loss() const {
  return _impl_.legacy_host_loss_;
}
inline uint32_t CNETMsg_Tick::legacy_host_loss() const {
  // @@protoc_insertion_point(field_get:CNETMsg_Tick.legacy_host_loss)
  return _internal_legacy_host_loss();
}
inline void CNETMsg_Tick::_internal_set_legacy_host_loss(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.legacy_host_loss_ = value;
}
inline void CNETMsg_Tick::set_legacy_host_loss(uint32_t value) {
  _internal_set_legacy_host_loss(value);
  // @@protoc_insertion_point(field_set:CNETMsg_Tick.legacy_host_loss)
}

// optional uint32 host_unfiltered_frametime = 8;
inline bool CNETMsg_Tick::_internal_has_host_unfiltered_frametime() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CNETMsg_Tick::has_host_unfiltered_frametime() const {
  return _internal_has_host_unfiltered_frametime();
}
inline void CNETMsg_Tick::clear_host_unfiltered_frametime() {
  _impl_.host_unfiltered_frametime_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CNETMsg_Tick::_internal_host_unfiltered_frametime() const {
  return _impl_.host_unfiltered_frametime_;
}
inline uint32_t CNETMsg_Tick::host_unfiltered_frametime() const {
  // @@protoc_insertion_point(field_get:CNETMsg_Tick.host_unfiltered_frametime)
  return _internal_host_unfiltered_frametime();
}
inline void CNETMsg_Tick::_internal_set_host_unfiltered_frametime(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.host_unfiltered_frametime_ = value;
}
inline void CNETMsg_Tick::set_host_unfiltered_frametime(uint32_t value) {
  _internal_set_host_unfiltered_frametime(value);
  // @@protoc_insertion_point(field_set:CNETMsg_Tick.host_unfiltered_frametime)
}

// optional uint32 hltv_replay_flags = 9;
inline bool CNETMsg_Tick::_internal_has_hltv_replay_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CNETMsg_Tick::has_hltv_replay_flags() const {
  return _internal_has_hltv_replay_flags();
}
inline void CNETMsg_Tick::clear_hltv_replay_flags() {
  _impl_.hltv_replay_flags_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CNETMsg_Tick::_internal_hltv_replay_flags() const {
  return _impl_.hltv_replay_flags_;
}
inline uint32_t CNETMsg_Tick::hltv_replay_flags() const {
  // @@protoc_insertion_point(field_get:CNETMsg_Tick.hltv_replay_flags)
  return _internal_hltv_replay_flags();
}
inline void CNETMsg_Tick::_internal_set_hltv_replay_flags(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.hltv_replay_flags_ = value;
}
inline void CNETMsg_Tick::set_hltv_replay_flags(uint32_t value) {
  _internal_set_hltv_replay_flags(value);
  // @@protoc_insertion_point(field_set:CNETMsg_Tick.hltv_replay_flags)
}

// optional uint32 expected_long_tick = 10;
inline bool CNETMsg_Tick::_internal_has_expected_long_tick() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CNETMsg_Tick::has_expected_long_tick() const {
  return _internal_has_expected_long_tick();
}
inline void CNETMsg_Tick::clear_expected_long_tick() {
  _impl_.expected_long_tick_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CNETMsg_Tick::_internal_expected_long_tick() const {
  return _impl_.expected_long_tick_;
}
inline uint32_t CNETMsg_Tick::expected_long_tick() const {
  // @@protoc_insertion_point(field_get:CNETMsg_Tick.expected_long_tick)
  return _internal_expected_long_tick();
}
inline void CNETMsg_Tick::_internal_set_expected_long_tick(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.expected_long_tick_ = value;
}
inline void CNETMsg_Tick::set_expected_long_tick(uint32_t value) {
  _internal_set_expected_long_tick(value);
  // @@protoc_insertion_point(field_set:CNETMsg_Tick.expected_long_tick)
}

// optional string expected_long_tick_reason = 11;
inline bool CNETMsg_Tick::_internal_has_expected_long_tick_reason() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CNETMsg_Tick::has_expected_long_tick_reason() const {
  return _internal_has_expected_long_tick_reason();
}
inline void CNETMsg_Tick::clear_expected_long_tick_reason() {
  _impl_.expected_long_tick_reason_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CNETMsg_Tick::expected_long_tick_reason() const {
  // @@protoc_insertion_point(field_get:CNETMsg_Tick.expected_long_tick_reason)
  return _internal_expected_long_tick_reason();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CNETMsg_Tick::set_expected_long_tick_reason(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.expected_long_tick_reason_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CNETMsg_Tick.expected_long_tick_reason)
}
inline std::string* CNETMsg_Tick::mutable_expected_long_tick_reason() {
  std::string* _s = _internal_mutable_expected_long_tick_reason();
  // @@protoc_insertion_point(field_mutable:CNETMsg_Tick.expected_long_tick_reason)
  return _s;
}
inline const std::string& CNETMsg_Tick::_internal_expected_long_tick_reason() const {
  return _impl_.expected_long_tick_reason_.Get();
}
inline void CNETMsg_Tick::_internal_set_expected_long_tick_reason(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.expected_long_tick_reason_.Set(value, GetArenaForAllocation());
}
inline std::string* CNETMsg_Tick::_internal_mutable_expected_long_tick_reason() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.expected_long_tick_reason_.Mutable(GetArenaForAllocation());
}
inline std::string* CNETMsg_Tick::release_expected_long_tick_reason() {
  // @@protoc_insertion_point(field_release:CNETMsg_Tick.expected_long_tick_reason)
  if (!_internal_has_expected_long_tick_reason()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.expected_long_tick_reason_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.expected_long_tick_reason_.IsDefault()) {
    _impl_.expected_long_tick_reason_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CNETMsg_Tick::set_allocated_expected_long_tick_reason(std::string* expected_long_tick_reason) {
  if (expected_long_tick_reason != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.expected_long_tick_reason_.SetAllocated(expected_long_tick_reason, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.expected_long_tick_reason_.IsDefault()) {
    _impl_.expected_long_tick_reason_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_Tick.expected_long_tick_reason)
}

// optional uint32 host_frame_dropped_pct_x10 = 12;
inline bool CNETMsg_Tick::_internal_has_host_frame_dropped_pct_x10() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CNETMsg_Tick::has_host_frame_dropped_pct_x10() const {
  return _internal_has_host_frame_dropped_pct_x10();
}
inline void CNETMsg_Tick::clear_host_frame_dropped_pct_x10() {
  _impl_.host_frame_dropped_pct_x10_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t CNETMsg_Tick::_internal_host_frame_dropped_pct_x10() const {
  return _impl_.host_frame_dropped_pct_x10_;
}
inline uint32_t CNETMsg_Tick::host_frame_dropped_pct_x10() const {
  // @@protoc_insertion_point(field_get:CNETMsg_Tick.host_frame_dropped_pct_x10)
  return _internal_host_frame_dropped_pct_x10();
}
inline void CNETMsg_Tick::_internal_set_host_frame_dropped_pct_x10(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.host_frame_dropped_pct_x10_ = value;
}
inline void CNETMsg_Tick::set_host_frame_dropped_pct_x10(uint32_t value) {
  _internal_set_host_frame_dropped_pct_x10(value);
  // @@protoc_insertion_point(field_set:CNETMsg_Tick.host_frame_dropped_pct_x10)
}

// optional uint32 host_frame_irregular_arrival_pct_x10 = 13;
inline bool CNETMsg_Tick::_internal_has_host_frame_irregular_arrival_pct_x10() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CNETMsg_Tick::has_host_frame_irregular_arrival_pct_x10() const {
  return _internal_has_host_frame_irregular_arrival_pct_x10();
}
inline void CNETMsg_Tick::clear_host_frame_irregular_arrival_pct_x10() {
  _impl_.host_frame_irregular_arrival_pct_x10_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t CNETMsg_Tick::_internal_host_frame_irregular_arrival_pct_x10() const {
  return _impl_.host_frame_irregular_arrival_pct_x10_;
}
inline uint32_t CNETMsg_Tick::host_frame_irregular_arrival_pct_x10() const {
  // @@protoc_insertion_point(field_get:CNETMsg_Tick.host_frame_irregular_arrival_pct_x10)
  return _internal_host_frame_irregular_arrival_pct_x10();
}
inline void CNETMsg_Tick::_internal_set_host_frame_irregular_arrival_pct_x10(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.host_frame_irregular_arrival_pct_x10_ = value;
}
inline void CNETMsg_Tick::set_host_frame_irregular_arrival_pct_x10(uint32_t value) {
  _internal_set_host_frame_irregular_arrival_pct_x10(value);
  // @@protoc_insertion_point(field_set:CNETMsg_Tick.host_frame_irregular_arrival_pct_x10)
}

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

// CNETMsg_StringCmd

// optional string command = 1;
inline bool CNETMsg_StringCmd::_internal_has_command() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CNETMsg_StringCmd::has_command() const {
  return _internal_has_command();
}
inline void CNETMsg_StringCmd::clear_command() {
  _impl_.command_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CNETMsg_StringCmd::command() const {
  // @@protoc_insertion_point(field_get:CNETMsg_StringCmd.command)
  return _internal_command();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CNETMsg_StringCmd::set_command(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.command_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CNETMsg_StringCmd.command)
}
inline std::string* CNETMsg_StringCmd::mutable_command() {
  std::string* _s = _internal_mutable_command();
  // @@protoc_insertion_point(field_mutable:CNETMsg_StringCmd.command)
  return _s;
}
inline const std::string& CNETMsg_StringCmd::_internal_command() const {
  return _impl_.command_.Get();
}
inline void CNETMsg_StringCmd::_internal_set_command(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.command_.Set(value, GetArenaForAllocation());
}
inline std::string* CNETMsg_StringCmd::_internal_mutable_command() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.command_.Mutable(GetArenaForAllocation());
}
inline std::string* CNETMsg_StringCmd::release_command() {
  // @@protoc_insertion_point(field_release:CNETMsg_StringCmd.command)
  if (!_internal_has_command()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.command_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.command_.IsDefault()) {
    _impl_.command_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CNETMsg_StringCmd::set_allocated_command(std::string* command) {
  if (command != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.command_.SetAllocated(command, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.command_.IsDefault()) {
    _impl_.command_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_StringCmd.command)
}

// optional uint32 prediction_sync = 2;
inline bool CNETMsg_StringCmd::_internal_has_prediction_sync() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CNETMsg_StringCmd::has_prediction_sync() const {
  return _internal_has_prediction_sync();
}
inline void CNETMsg_StringCmd::clear_prediction_sync() {
  _impl_.prediction_sync_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CNETMsg_StringCmd::_internal_prediction_sync() const {
  return _impl_.prediction_sync_;
}
inline uint32_t CNETMsg_StringCmd::prediction_sync() const {
  // @@protoc_insertion_point(field_get:CNETMsg_StringCmd.prediction_sync)
  return _internal_prediction_sync();
}
inline void CNETMsg_StringCmd::_internal_set_prediction_sync(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.prediction_sync_ = value;
}
inline void CNETMsg_StringCmd::set_prediction_sync(uint32_t value) {
  _internal_set_prediction_sync(value);
  // @@protoc_insertion_point(field_set:CNETMsg_StringCmd.prediction_sync)
}

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

// CNETMsg_SetConVar

// optional .CMsg_CVars convars = 1;
inline bool CNETMsg_SetConVar::_internal_has_convars() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.convars_ != nullptr);
  return value;
}
inline bool CNETMsg_SetConVar::has_convars() const {
  return _internal_has_convars();
}
inline void CNETMsg_SetConVar::clear_convars() {
  if (_impl_.convars_ != nullptr) _impl_.convars_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsg_CVars& CNETMsg_SetConVar::_internal_convars() const {
  const ::CMsg_CVars* p = _impl_.convars_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsg_CVars&>(
      ::_CMsg_CVars_default_instance_);
}
inline const ::CMsg_CVars& CNETMsg_SetConVar::convars() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SetConVar.convars)
  return _internal_convars();
}
inline void CNETMsg_SetConVar::unsafe_arena_set_allocated_convars(
    ::CMsg_CVars* convars) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.convars_);
  }
  _impl_.convars_ = convars;
  if (convars) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CNETMsg_SetConVar.convars)
}
inline ::CMsg_CVars* CNETMsg_SetConVar::release_convars() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsg_CVars* temp = _impl_.convars_;
  _impl_.convars_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsg_CVars* CNETMsg_SetConVar::unsafe_arena_release_convars() {
  // @@protoc_insertion_point(field_release:CNETMsg_SetConVar.convars)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsg_CVars* temp = _impl_.convars_;
  _impl_.convars_ = nullptr;
  return temp;
}
inline ::CMsg_CVars* CNETMsg_SetConVar::_internal_mutable_convars() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.convars_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsg_CVars>(GetArenaForAllocation());
    _impl_.convars_ = p;
  }
  return _impl_.convars_;
}
inline ::CMsg_CVars* CNETMsg_SetConVar::mutable_convars() {
  ::CMsg_CVars* _msg = _internal_mutable_convars();
  // @@protoc_insertion_point(field_mutable:CNETMsg_SetConVar.convars)
  return _msg;
}
inline void CNETMsg_SetConVar::set_allocated_convars(::CMsg_CVars* convars) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.convars_;
  }
  if (convars) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(convars);
    if (message_arena != submessage_arena) {
      convars = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, convars, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.convars_ = convars;
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_SetConVar.convars)
}

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

// CNETMsg_SignonState

// optional .SignonState_t signon_state = 1 [default = SIGNONSTATE_NONE];
inline bool CNETMsg_SignonState::_internal_has_signon_state() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CNETMsg_SignonState::has_signon_state() const {
  return _internal_has_signon_state();
}
inline void CNETMsg_SignonState::clear_signon_state() {
  _impl_.signon_state_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::SignonState_t CNETMsg_SignonState::_internal_signon_state() const {
  return static_cast< ::SignonState_t >(_impl_.signon_state_);
}
inline ::SignonState_t CNETMsg_SignonState::signon_state() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SignonState.signon_state)
  return _internal_signon_state();
}
inline void CNETMsg_SignonState::_internal_set_signon_state(::SignonState_t value) {
  assert(::SignonState_t_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.signon_state_ = value;
}
inline void CNETMsg_SignonState::set_signon_state(::SignonState_t value) {
  _internal_set_signon_state(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SignonState.signon_state)
}

// optional uint32 spawn_count = 2;
inline bool CNETMsg_SignonState::_internal_has_spawn_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CNETMsg_SignonState::has_spawn_count() const {
  return _internal_has_spawn_count();
}
inline void CNETMsg_SignonState::clear_spawn_count() {
  _impl_.spawn_count_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CNETMsg_SignonState::_internal_spawn_count() const {
  return _impl_.spawn_count_;
}
inline uint32_t CNETMsg_SignonState::spawn_count() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SignonState.spawn_count)
  return _internal_spawn_count();
}
inline void CNETMsg_SignonState::_internal_set_spawn_count(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.spawn_count_ = value;
}
inline void CNETMsg_SignonState::set_spawn_count(uint32_t value) {
  _internal_set_spawn_count(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SignonState.spawn_count)
}

// optional uint32 num_server_players = 3;
inline bool CNETMsg_SignonState::_internal_has_num_server_players() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CNETMsg_SignonState::has_num_server_players() const {
  return _internal_has_num_server_players();
}
inline void CNETMsg_SignonState::clear_num_server_players() {
  _impl_.num_server_players_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CNETMsg_SignonState::_internal_num_server_players() const {
  return _impl_.num_server_players_;
}
inline uint32_t CNETMsg_SignonState::num_server_players() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SignonState.num_server_players)
  return _internal_num_server_players();
}
inline void CNETMsg_SignonState::_internal_set_num_server_players(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.num_server_players_ = value;
}
inline void CNETMsg_SignonState::set_num_server_players(uint32_t value) {
  _internal_set_num_server_players(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SignonState.num_server_players)
}

// repeated string players_networkids = 4;
inline int CNETMsg_SignonState::_internal_players_networkids_size() const {
  return _impl_.players_networkids_.size();
}
inline int CNETMsg_SignonState::players_networkids_size() const {
  return _internal_players_networkids_size();
}
inline void CNETMsg_SignonState::clear_players_networkids() {
  _impl_.players_networkids_.Clear();
}
inline std::string* CNETMsg_SignonState::add_players_networkids() {
  std::string* _s = _internal_add_players_networkids();
  // @@protoc_insertion_point(field_add_mutable:CNETMsg_SignonState.players_networkids)
  return _s;
}
inline const std::string& CNETMsg_SignonState::_internal_players_networkids(int index) const {
  return _impl_.players_networkids_.Get(index);
}
inline const std::string& CNETMsg_SignonState::players_networkids(int index) const {
  // @@protoc_insertion_point(field_get:CNETMsg_SignonState.players_networkids)
  return _internal_players_networkids(index);
}
inline std::string* CNETMsg_SignonState::mutable_players_networkids(int index) {
  // @@protoc_insertion_point(field_mutable:CNETMsg_SignonState.players_networkids)
  return _impl_.players_networkids_.Mutable(index);
}
inline void CNETMsg_SignonState::set_players_networkids(int index, const std::string& value) {
  _impl_.players_networkids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SignonState.players_networkids)
}
inline void CNETMsg_SignonState::set_players_networkids(int index, std::string&& value) {
  _impl_.players_networkids_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:CNETMsg_SignonState.players_networkids)
}
inline void CNETMsg_SignonState::set_players_networkids(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.players_networkids_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:CNETMsg_SignonState.players_networkids)
}
inline void CNETMsg_SignonState::set_players_networkids(int index, const char* value, size_t size) {
  _impl_.players_networkids_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:CNETMsg_SignonState.players_networkids)
}
inline std::string* CNETMsg_SignonState::_internal_add_players_networkids() {
  return _impl_.players_networkids_.Add();
}
inline void CNETMsg_SignonState::add_players_networkids(const std::string& value) {
  _impl_.players_networkids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:CNETMsg_SignonState.players_networkids)
}
inline void CNETMsg_SignonState::add_players_networkids(std::string&& value) {
  _impl_.players_networkids_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:CNETMsg_SignonState.players_networkids)
}
inline void CNETMsg_SignonState::add_players_networkids(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.players_networkids_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:CNETMsg_SignonState.players_networkids)
}
inline void CNETMsg_SignonState::add_players_networkids(const char* value, size_t size) {
  _impl_.players_networkids_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:CNETMsg_SignonState.players_networkids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
CNETMsg_SignonState::players_networkids() const {
  // @@protoc_insertion_point(field_list:CNETMsg_SignonState.players_networkids)
  return _impl_.players_networkids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
CNETMsg_SignonState::mutable_players_networkids() {
  // @@protoc_insertion_point(field_mutable_list:CNETMsg_SignonState.players_networkids)
  return &_impl_.players_networkids_;
}

// optional string map_name = 5;
inline bool CNETMsg_SignonState::_internal_has_map_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CNETMsg_SignonState::has_map_name() const {
  return _internal_has_map_name();
}
inline void CNETMsg_SignonState::clear_map_name() {
  _impl_.map_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CNETMsg_SignonState::map_name() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SignonState.map_name)
  return _internal_map_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CNETMsg_SignonState::set_map_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.map_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CNETMsg_SignonState.map_name)
}
inline std::string* CNETMsg_SignonState::mutable_map_name() {
  std::string* _s = _internal_mutable_map_name();
  // @@protoc_insertion_point(field_mutable:CNETMsg_SignonState.map_name)
  return _s;
}
inline const std::string& CNETMsg_SignonState::_internal_map_name() const {
  return _impl_.map_name_.Get();
}
inline void CNETMsg_SignonState::_internal_set_map_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.map_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CNETMsg_SignonState::_internal_mutable_map_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.map_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CNETMsg_SignonState::release_map_name() {
  // @@protoc_insertion_point(field_release:CNETMsg_SignonState.map_name)
  if (!_internal_has_map_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.map_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.map_name_.IsDefault()) {
    _impl_.map_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CNETMsg_SignonState::set_allocated_map_name(std::string* map_name) {
  if (map_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.map_name_.SetAllocated(map_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.map_name_.IsDefault()) {
    _impl_.map_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_SignonState.map_name)
}

// optional string addons = 6;
inline bool CNETMsg_SignonState::_internal_has_addons() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CNETMsg_SignonState::has_addons() const {
  return _internal_has_addons();
}
inline void CNETMsg_SignonState::clear_addons() {
  _impl_.addons_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CNETMsg_SignonState::addons() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SignonState.addons)
  return _internal_addons();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CNETMsg_SignonState::set_addons(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.addons_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CNETMsg_SignonState.addons)
}
inline std::string* CNETMsg_SignonState::mutable_addons() {
  std::string* _s = _internal_mutable_addons();
  // @@protoc_insertion_point(field_mutable:CNETMsg_SignonState.addons)
  return _s;
}
inline const std::string& CNETMsg_SignonState::_internal_addons() const {
  return _impl_.addons_.Get();
}
inline void CNETMsg_SignonState::_internal_set_addons(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.addons_.Set(value, GetArenaForAllocation());
}
inline std::string* CNETMsg_SignonState::_internal_mutable_addons() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.addons_.Mutable(GetArenaForAllocation());
}
inline std::string* CNETMsg_SignonState::release_addons() {
  // @@protoc_insertion_point(field_release:CNETMsg_SignonState.addons)
  if (!_internal_has_addons()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.addons_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.addons_.IsDefault()) {
    _impl_.addons_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CNETMsg_SignonState::set_allocated_addons(std::string* addons) {
  if (addons != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.addons_.SetAllocated(addons, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.addons_.IsDefault()) {
    _impl_.addons_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_SignonState.addons)
}

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

// CSVCMsg_GameEvent_key_t

// optional int32 type = 1;
inline bool CSVCMsg_GameEvent_key_t::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_GameEvent_key_t::has_type() const {
  return _internal_has_type();
}
inline void CSVCMsg_GameEvent_key_t::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_GameEvent_key_t::_internal_type() const {
  return _impl_.type_;
}
inline int32_t CSVCMsg_GameEvent_key_t::type() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEvent.key_t.type)
  return _internal_type();
}
inline void CSVCMsg_GameEvent_key_t::_internal_set_type(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.type_ = value;
}
inline void CSVCMsg_GameEvent_key_t::set_type(int32_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameEvent.key_t.type)
}

// optional string val_string = 2;
inline bool CSVCMsg_GameEvent_key_t::_internal_has_val_string() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_GameEvent_key_t::has_val_string() const {
  return _internal_has_val_string();
}
inline void CSVCMsg_GameEvent_key_t::clear_val_string() {
  _impl_.val_string_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_GameEvent_key_t::val_string() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEvent.key_t.val_string)
  return _internal_val_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_GameEvent_key_t::set_val_string(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.val_string_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_GameEvent.key_t.val_string)
}
inline std::string* CSVCMsg_GameEvent_key_t::mutable_val_string() {
  std::string* _s = _internal_mutable_val_string();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GameEvent.key_t.val_string)
  return _s;
}
inline const std::string& CSVCMsg_GameEvent_key_t::_internal_val_string() const {
  return _impl_.val_string_.Get();
}
inline void CSVCMsg_GameEvent_key_t::_internal_set_val_string(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.val_string_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameEvent_key_t::_internal_mutable_val_string() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.val_string_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameEvent_key_t::release_val_string() {
  // @@protoc_insertion_point(field_release:CSVCMsg_GameEvent.key_t.val_string)
  if (!_internal_has_val_string()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.val_string_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.val_string_.IsDefault()) {
    _impl_.val_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_GameEvent_key_t::set_allocated_val_string(std::string* val_string) {
  if (val_string != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.val_string_.SetAllocated(val_string, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.val_string_.IsDefault()) {
    _impl_.val_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_GameEvent.key_t.val_string)
}

// optional float val_float = 3;
inline bool CSVCMsg_GameEvent_key_t::_internal_has_val_float() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_GameEvent_key_t::has_val_float() const {
  return _internal_has_val_float();
}
inline void CSVCMsg_GameEvent_key_t::clear_val_float() {
  _impl_.val_float_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CSVCMsg_GameEvent_key_t::_internal_val_float() const {
  return _impl_.val_float_;
}
inline float CSVCMsg_GameEvent_key_t::val_float() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEvent.key_t.val_float)
  return _internal_val_float();
}
inline void CSVCMsg_GameEvent_key_t::_internal_set_val_float(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.val_float_ = value;
}
inline void CSVCMsg_GameEvent_key_t::set_val_float(float value) {
  _internal_set_val_float(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameEvent.key_t.val_float)
}

// optional int32 val_long = 4;
inline bool CSVCMsg_GameEvent_key_t::_internal_has_val_long() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSVCMsg_GameEvent_key_t::has_val_long() const {
  return _internal_has_val_long();
}
inline void CSVCMsg_GameEvent_key_t::clear_val_long() {
  _impl_.val_long_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CSVCMsg_GameEvent_key_t::_internal_val_long() const {
  return _impl_.val_long_;
}
inline int32_t CSVCMsg_GameEvent_key_t::val_long() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEvent.key_t.val_long)
  return _internal_val_long();
}
inline void CSVCMsg_GameEvent_key_t::_internal_set_val_long(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.val_long_ = value;
}
inline void CSVCMsg_GameEvent_key_t::set_val_long(int32_t value) {
  _internal_set_val_long(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameEvent.key_t.val_long)
}

// optional int32 val_short = 5;
inline bool CSVCMsg_GameEvent_key_t::_internal_has_val_short() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSVCMsg_GameEvent_key_t::has_val_short() const {
  return _internal_has_val_short();
}
inline void CSVCMsg_GameEvent_key_t::clear_val_short() {
  _impl_.val_short_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CSVCMsg_GameEvent_key_t::_internal_val_short() const {
  return _impl_.val_short_;
}
inline int32_t CSVCMsg_GameEvent_key_t::val_short() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEvent.key_t.val_short)
  return _internal_val_short();
}
inline void CSVCMsg_GameEvent_key_t::_internal_set_val_short(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.val_short_ = value;
}
inline void CSVCMsg_GameEvent_key_t::set_val_short(int32_t value) {
  _internal_set_val_short(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameEvent.key_t.val_short)
}

// optional int32 val_byte = 6;
inline bool CSVCMsg_GameEvent_key_t::_internal_has_val_byte() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CSVCMsg_GameEvent_key_t::has_val_byte() const {
  return _internal_has_val_byte();
}
inline void CSVCMsg_GameEvent_key_t::clear_val_byte() {
  _impl_.val_byte_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CSVCMsg_GameEvent_key_t::_internal_val_byte() const {
  return _impl_.val_byte_;
}
inline int32_t CSVCMsg_GameEvent_key_t::val_byte() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEvent.key_t.val_byte)
  return _internal_val_byte();
}
inline void CSVCMsg_GameEvent_key_t::_internal_set_val_byte(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.val_byte_ = value;
}
inline void CSVCMsg_GameEvent_key_t::set_val_byte(int32_t value) {
  _internal_set_val_byte(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameEvent.key_t.val_byte)
}

// optional bool val_bool = 7;
inline bool CSVCMsg_GameEvent_key_t::_internal_has_val_bool() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CSVCMsg_GameEvent_key_t::has_val_bool() const {
  return _internal_has_val_bool();
}
inline void CSVCMsg_GameEvent_key_t::clear_val_bool() {
  _impl_.val_bool_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool CSVCMsg_GameEvent_key_t::_internal_val_bool() const {
  return _impl_.val_bool_;
}
inline bool CSVCMsg_GameEvent_key_t::val_bool() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEvent.key_t.val_bool)
  return _internal_val_bool();
}
inline void CSVCMsg_GameEvent_key_t::_internal_set_val_bool(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.val_bool_ = value;
}
inline void CSVCMsg_GameEvent_key_t::set_val_bool(bool value) {
  _internal_set_val_bool(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameEvent.key_t.val_bool)
}

// optional uint64 val_uint64 = 8;
inline bool CSVCMsg_GameEvent_key_t::_internal_has_val_uint64() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CSVCMsg_GameEvent_key_t::has_val_uint64() const {
  return _internal_has_val_uint64();
}
inline void CSVCMsg_GameEvent_key_t::clear_val_uint64() {
  _impl_.val_uint64_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint64_t CSVCMsg_GameEvent_key_t::_internal_val_uint64() const {
  return _impl_.val_uint64_;
}
inline uint64_t CSVCMsg_GameEvent_key_t::val_uint64() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEvent.key_t.val_uint64)
  return _internal_val_uint64();
}
inline void CSVCMsg_GameEvent_key_t::_internal_set_val_uint64(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.val_uint64_ = value;
}
inline void CSVCMsg_GameEvent_key_t::set_val_uint64(uint64_t value) {
  _internal_set_val_uint64(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameEvent.key_t.val_uint64)
}

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

// CSVCMsg_GameEvent

// optional string event_name = 1;
inline bool CSVCMsg_GameEvent::_internal_has_event_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_GameEvent::has_event_name() const {
  return _internal_has_event_name();
}
inline void CSVCMsg_GameEvent::clear_event_name() {
  _impl_.event_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_GameEvent::event_name() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEvent.event_name)
  return _internal_event_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_GameEvent::set_event_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.event_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_GameEvent.event_name)
}
inline std::string* CSVCMsg_GameEvent::mutable_event_name() {
  std::string* _s = _internal_mutable_event_name();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GameEvent.event_name)
  return _s;
}
inline const std::string& CSVCMsg_GameEvent::_internal_event_name() const {
  return _impl_.event_name_.Get();
}
inline void CSVCMsg_GameEvent::_internal_set_event_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.event_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameEvent::_internal_mutable_event_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.event_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameEvent::release_event_name() {
  // @@protoc_insertion_point(field_release:CSVCMsg_GameEvent.event_name)
  if (!_internal_has_event_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.event_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.event_name_.IsDefault()) {
    _impl_.event_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_GameEvent::set_allocated_event_name(std::string* event_name) {
  if (event_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.event_name_.SetAllocated(event_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.event_name_.IsDefault()) {
    _impl_.event_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_GameEvent.event_name)
}

// optional int32 eventid = 2;
inline bool CSVCMsg_GameEvent::_internal_has_eventid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_GameEvent::has_eventid() const {
  return _internal_has_eventid();
}
inline void CSVCMsg_GameEvent::clear_eventid() {
  _impl_.eventid_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsg_GameEvent::_internal_eventid() const {
  return _impl_.eventid_;
}
inline int32_t CSVCMsg_GameEvent::eventid() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEvent.eventid)
  return _internal_eventid();
}
inline void CSVCMsg_GameEvent::_internal_set_eventid(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.eventid_ = value;
}
inline void CSVCMsg_GameEvent::set_eventid(int32_t value) {
  _internal_set_eventid(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameEvent.eventid)
}

// repeated .CSVCMsg_GameEvent.key_t keys = 3;
inline int CSVCMsg_GameEvent::_internal_keys_size() const {
  return _impl_.keys_.size();
}
inline int CSVCMsg_GameEvent::keys_size() const {
  return _internal_keys_size();
}
inline void CSVCMsg_GameEvent::clear_keys() {
  _impl_.keys_.Clear();
}
inline ::CSVCMsg_GameEvent_key_t* CSVCMsg_GameEvent::mutable_keys(int index) {
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GameEvent.keys)
  return _impl_.keys_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_GameEvent_key_t >*
CSVCMsg_GameEvent::mutable_keys() {
  // @@protoc_insertion_point(field_mutable_list:CSVCMsg_GameEvent.keys)
  return &_impl_.keys_;
}
inline const ::CSVCMsg_GameEvent_key_t& CSVCMsg_GameEvent::_internal_keys(int index) const {
  return _impl_.keys_.Get(index);
}
inline const ::CSVCMsg_GameEvent_key_t& CSVCMsg_GameEvent::keys(int index) const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameEvent.keys)
  return _internal_keys(index);
}
inline ::CSVCMsg_GameEvent_key_t* CSVCMsg_GameEvent::_internal_add_keys() {
  return _impl_.keys_.Add();
}
inline ::CSVCMsg_GameEvent_key_t* CSVCMsg_GameEvent::add_keys() {
  ::CSVCMsg_GameEvent_key_t* _add = _internal_add_keys();
  // @@protoc_insertion_point(field_add:CSVCMsg_GameEvent.keys)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsg_GameEvent_key_t >&
CSVCMsg_GameEvent::keys() const {
  // @@protoc_insertion_point(field_list:CSVCMsg_GameEvent.keys)
  return _impl_.keys_;
}

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

// CSVCMsgList_GameEvents_event_t

// optional int32 tick = 1;
inline bool CSVCMsgList_GameEvents_event_t::_internal_has_tick() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsgList_GameEvents_event_t::has_tick() const {
  return _internal_has_tick();
}
inline void CSVCMsgList_GameEvents_event_t::clear_tick() {
  _impl_.tick_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CSVCMsgList_GameEvents_event_t::_internal_tick() const {
  return _impl_.tick_;
}
inline int32_t CSVCMsgList_GameEvents_event_t::tick() const {
  // @@protoc_insertion_point(field_get:CSVCMsgList_GameEvents.event_t.tick)
  return _internal_tick();
}
inline void CSVCMsgList_GameEvents_event_t::_internal_set_tick(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.tick_ = value;
}
inline void CSVCMsgList_GameEvents_event_t::set_tick(int32_t value) {
  _internal_set_tick(value);
  // @@protoc_insertion_point(field_set:CSVCMsgList_GameEvents.event_t.tick)
}

// optional .CSVCMsg_GameEvent event = 2;
inline bool CSVCMsgList_GameEvents_event_t::_internal_has_event() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.event_ != nullptr);
  return value;
}
inline bool CSVCMsgList_GameEvents_event_t::has_event() const {
  return _internal_has_event();
}
inline void CSVCMsgList_GameEvents_event_t::clear_event() {
  if (_impl_.event_ != nullptr) _impl_.event_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CSVCMsg_GameEvent& CSVCMsgList_GameEvents_event_t::_internal_event() const {
  const ::CSVCMsg_GameEvent* p = _impl_.event_;
  return p != nullptr ? *p : reinterpret_cast<const ::CSVCMsg_GameEvent&>(
      ::_CSVCMsg_GameEvent_default_instance_);
}
inline const ::CSVCMsg_GameEvent& CSVCMsgList_GameEvents_event_t::event() const {
  // @@protoc_insertion_point(field_get:CSVCMsgList_GameEvents.event_t.event)
  return _internal_event();
}
inline void CSVCMsgList_GameEvents_event_t::unsafe_arena_set_allocated_event(
    ::CSVCMsg_GameEvent* event) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.event_);
  }
  _impl_.event_ = event;
  if (event) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CSVCMsgList_GameEvents.event_t.event)
}
inline ::CSVCMsg_GameEvent* CSVCMsgList_GameEvents_event_t::release_event() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CSVCMsg_GameEvent* temp = _impl_.event_;
  _impl_.event_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CSVCMsg_GameEvent* CSVCMsgList_GameEvents_event_t::unsafe_arena_release_event() {
  // @@protoc_insertion_point(field_release:CSVCMsgList_GameEvents.event_t.event)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CSVCMsg_GameEvent* temp = _impl_.event_;
  _impl_.event_ = nullptr;
  return temp;
}
inline ::CSVCMsg_GameEvent* CSVCMsgList_GameEvents_event_t::_internal_mutable_event() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.event_ == nullptr) {
    auto* p = CreateMaybeMessage<::CSVCMsg_GameEvent>(GetArenaForAllocation());
    _impl_.event_ = p;
  }
  return _impl_.event_;
}
inline ::CSVCMsg_GameEvent* CSVCMsgList_GameEvents_event_t::mutable_event() {
  ::CSVCMsg_GameEvent* _msg = _internal_mutable_event();
  // @@protoc_insertion_point(field_mutable:CSVCMsgList_GameEvents.event_t.event)
  return _msg;
}
inline void CSVCMsgList_GameEvents_event_t::set_allocated_event(::CSVCMsg_GameEvent* event) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.event_;
  }
  if (event) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(event);
    if (message_arena != submessage_arena) {
      event = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, event, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.event_ = event;
  // @@protoc_insertion_point(field_set_allocated:CSVCMsgList_GameEvents.event_t.event)
}

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

// CSVCMsgList_GameEvents

// repeated .CSVCMsgList_GameEvents.event_t events = 1;
inline int CSVCMsgList_GameEvents::_internal_events_size() const {
  return _impl_.events_.size();
}
inline int CSVCMsgList_GameEvents::events_size() const {
  return _internal_events_size();
}
inline void CSVCMsgList_GameEvents::clear_events() {
  _impl_.events_.Clear();
}
inline ::CSVCMsgList_GameEvents_event_t* CSVCMsgList_GameEvents::mutable_events(int index) {
  // @@protoc_insertion_point(field_mutable:CSVCMsgList_GameEvents.events)
  return _impl_.events_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsgList_GameEvents_event_t >*
CSVCMsgList_GameEvents::mutable_events() {
  // @@protoc_insertion_point(field_mutable_list:CSVCMsgList_GameEvents.events)
  return &_impl_.events_;
}
inline const ::CSVCMsgList_GameEvents_event_t& CSVCMsgList_GameEvents::_internal_events(int index) const {
  return _impl_.events_.Get(index);
}
inline const ::CSVCMsgList_GameEvents_event_t& CSVCMsgList_GameEvents::events(int index) const {
  // @@protoc_insertion_point(field_get:CSVCMsgList_GameEvents.events)
  return _internal_events(index);
}
inline ::CSVCMsgList_GameEvents_event_t* CSVCMsgList_GameEvents::_internal_add_events() {
  return _impl_.events_.Add();
}
inline ::CSVCMsgList_GameEvents_event_t* CSVCMsgList_GameEvents::add_events() {
  ::CSVCMsgList_GameEvents_event_t* _add = _internal_add_events();
  // @@protoc_insertion_point(field_add:CSVCMsgList_GameEvents.events)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSVCMsgList_GameEvents_event_t >&
CSVCMsgList_GameEvents::events() const {
  // @@protoc_insertion_point(field_list:CSVCMsgList_GameEvents.events)
  return _impl_.events_;
}

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

// CNETMsg_SpawnGroup_Load

// optional string worldname = 1;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_worldname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_worldname() const {
  return _internal_has_worldname();
}
inline void CNETMsg_SpawnGroup_Load::clear_worldname() {
  _impl_.worldname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CNETMsg_SpawnGroup_Load::worldname() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.worldname)
  return _internal_worldname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CNETMsg_SpawnGroup_Load::set_worldname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.worldname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.worldname)
}
inline std::string* CNETMsg_SpawnGroup_Load::mutable_worldname() {
  std::string* _s = _internal_mutable_worldname();
  // @@protoc_insertion_point(field_mutable:CNETMsg_SpawnGroup_Load.worldname)
  return _s;
}
inline const std::string& CNETMsg_SpawnGroup_Load::_internal_worldname() const {
  return _impl_.worldname_.Get();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_worldname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.worldname_.Set(value, GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::_internal_mutable_worldname() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.worldname_.Mutable(GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::release_worldname() {
  // @@protoc_insertion_point(field_release:CNETMsg_SpawnGroup_Load.worldname)
  if (!_internal_has_worldname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.worldname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.worldname_.IsDefault()) {
    _impl_.worldname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CNETMsg_SpawnGroup_Load::set_allocated_worldname(std::string* worldname) {
  if (worldname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.worldname_.SetAllocated(worldname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.worldname_.IsDefault()) {
    _impl_.worldname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_SpawnGroup_Load.worldname)
}

// optional string entitylumpname = 2;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_entitylumpname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_entitylumpname() const {
  return _internal_has_entitylumpname();
}
inline void CNETMsg_SpawnGroup_Load::clear_entitylumpname() {
  _impl_.entitylumpname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CNETMsg_SpawnGroup_Load::entitylumpname() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.entitylumpname)
  return _internal_entitylumpname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CNETMsg_SpawnGroup_Load::set_entitylumpname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.entitylumpname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.entitylumpname)
}
inline std::string* CNETMsg_SpawnGroup_Load::mutable_entitylumpname() {
  std::string* _s = _internal_mutable_entitylumpname();
  // @@protoc_insertion_point(field_mutable:CNETMsg_SpawnGroup_Load.entitylumpname)
  return _s;
}
inline const std::string& CNETMsg_SpawnGroup_Load::_internal_entitylumpname() const {
  return _impl_.entitylumpname_.Get();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_entitylumpname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.entitylumpname_.Set(value, GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::_internal_mutable_entitylumpname() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.entitylumpname_.Mutable(GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::release_entitylumpname() {
  // @@protoc_insertion_point(field_release:CNETMsg_SpawnGroup_Load.entitylumpname)
  if (!_internal_has_entitylumpname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.entitylumpname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.entitylumpname_.IsDefault()) {
    _impl_.entitylumpname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CNETMsg_SpawnGroup_Load::set_allocated_entitylumpname(std::string* entitylumpname) {
  if (entitylumpname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.entitylumpname_.SetAllocated(entitylumpname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.entitylumpname_.IsDefault()) {
    _impl_.entitylumpname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_SpawnGroup_Load.entitylumpname)
}

// optional string entityfiltername = 3;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_entityfiltername() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_entityfiltername() const {
  return _internal_has_entityfiltername();
}
inline void CNETMsg_SpawnGroup_Load::clear_entityfiltername() {
  _impl_.entityfiltername_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CNETMsg_SpawnGroup_Load::entityfiltername() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.entityfiltername)
  return _internal_entityfiltername();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CNETMsg_SpawnGroup_Load::set_entityfiltername(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.entityfiltername_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.entityfiltername)
}
inline std::string* CNETMsg_SpawnGroup_Load::mutable_entityfiltername() {
  std::string* _s = _internal_mutable_entityfiltername();
  // @@protoc_insertion_point(field_mutable:CNETMsg_SpawnGroup_Load.entityfiltername)
  return _s;
}
inline const std::string& CNETMsg_SpawnGroup_Load::_internal_entityfiltername() const {
  return _impl_.entityfiltername_.Get();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_entityfiltername(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.entityfiltername_.Set(value, GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::_internal_mutable_entityfiltername() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.entityfiltername_.Mutable(GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::release_entityfiltername() {
  // @@protoc_insertion_point(field_release:CNETMsg_SpawnGroup_Load.entityfiltername)
  if (!_internal_has_entityfiltername()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.entityfiltername_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.entityfiltername_.IsDefault()) {
    _impl_.entityfiltername_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CNETMsg_SpawnGroup_Load::set_allocated_entityfiltername(std::string* entityfiltername) {
  if (entityfiltername != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.entityfiltername_.SetAllocated(entityfiltername, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.entityfiltername_.IsDefault()) {
    _impl_.entityfiltername_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_SpawnGroup_Load.entityfiltername)
}

// optional uint32 spawngrouphandle = 4;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_spawngrouphandle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_spawngrouphandle() const {
  return _internal_has_spawngrouphandle();
}
inline void CNETMsg_SpawnGroup_Load::clear_spawngrouphandle() {
  _impl_.spawngrouphandle_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CNETMsg_SpawnGroup_Load::_internal_spawngrouphandle() const {
  return _impl_.spawngrouphandle_;
}
inline uint32_t CNETMsg_SpawnGroup_Load::spawngrouphandle() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.spawngrouphandle)
  return _internal_spawngrouphandle();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_spawngrouphandle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.spawngrouphandle_ = value;
}
inline void CNETMsg_SpawnGroup_Load::set_spawngrouphandle(uint32_t value) {
  _internal_set_spawngrouphandle(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.spawngrouphandle)
}

// optional uint32 spawngroupownerhandle = 5;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_spawngroupownerhandle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_spawngroupownerhandle() const {
  return _internal_has_spawngroupownerhandle();
}
inline void CNETMsg_SpawnGroup_Load::clear_spawngroupownerhandle() {
  _impl_.spawngroupownerhandle_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t CNETMsg_SpawnGroup_Load::_internal_spawngroupownerhandle() const {
  return _impl_.spawngroupownerhandle_;
}
inline uint32_t CNETMsg_SpawnGroup_Load::spawngroupownerhandle() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.spawngroupownerhandle)
  return _internal_spawngroupownerhandle();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_spawngroupownerhandle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.spawngroupownerhandle_ = value;
}
inline void CNETMsg_SpawnGroup_Load::set_spawngroupownerhandle(uint32_t value) {
  _internal_set_spawngroupownerhandle(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.spawngroupownerhandle)
}

// optional .CMsgVector world_offset_pos = 6;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_world_offset_pos() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.world_offset_pos_ != nullptr);
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_world_offset_pos() const {
  return _internal_has_world_offset_pos();
}
inline void CNETMsg_SpawnGroup_Load::clear_world_offset_pos() {
  if (_impl_.world_offset_pos_ != nullptr) _impl_.world_offset_pos_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::CMsgVector& CNETMsg_SpawnGroup_Load::_internal_world_offset_pos() const {
  const ::CMsgVector* p = _impl_.world_offset_pos_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CNETMsg_SpawnGroup_Load::world_offset_pos() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.world_offset_pos)
  return _internal_world_offset_pos();
}
inline void CNETMsg_SpawnGroup_Load::unsafe_arena_set_allocated_world_offset_pos(
    ::CMsgVector* world_offset_pos) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.world_offset_pos_);
  }
  _impl_.world_offset_pos_ = world_offset_pos;
  if (world_offset_pos) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CNETMsg_SpawnGroup_Load.world_offset_pos)
}
inline ::CMsgVector* CNETMsg_SpawnGroup_Load::release_world_offset_pos() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::CMsgVector* temp = _impl_.world_offset_pos_;
  _impl_.world_offset_pos_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CNETMsg_SpawnGroup_Load::unsafe_arena_release_world_offset_pos() {
  // @@protoc_insertion_point(field_release:CNETMsg_SpawnGroup_Load.world_offset_pos)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::CMsgVector* temp = _impl_.world_offset_pos_;
  _impl_.world_offset_pos_ = nullptr;
  return temp;
}
inline ::CMsgVector* CNETMsg_SpawnGroup_Load::_internal_mutable_world_offset_pos() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.world_offset_pos_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.world_offset_pos_ = p;
  }
  return _impl_.world_offset_pos_;
}
inline ::CMsgVector* CNETMsg_SpawnGroup_Load::mutable_world_offset_pos() {
  ::CMsgVector* _msg = _internal_mutable_world_offset_pos();
  // @@protoc_insertion_point(field_mutable:CNETMsg_SpawnGroup_Load.world_offset_pos)
  return _msg;
}
inline void CNETMsg_SpawnGroup_Load::set_allocated_world_offset_pos(::CMsgVector* world_offset_pos) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.world_offset_pos_;
  }
  if (world_offset_pos) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(world_offset_pos);
    if (message_arena != submessage_arena) {
      world_offset_pos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, world_offset_pos, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.world_offset_pos_ = world_offset_pos;
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_SpawnGroup_Load.world_offset_pos)
}

// optional .CMsgQAngle world_offset_angle = 7;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_world_offset_angle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.world_offset_angle_ != nullptr);
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_world_offset_angle() const {
  return _internal_has_world_offset_angle();
}
inline void CNETMsg_SpawnGroup_Load::clear_world_offset_angle() {
  if (_impl_.world_offset_angle_ != nullptr) _impl_.world_offset_angle_->Clear();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const ::CMsgQAngle& CNETMsg_SpawnGroup_Load::_internal_world_offset_angle() const {
  const ::CMsgQAngle* p = _impl_.world_offset_angle_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQAngle&>(
      ::_CMsgQAngle_default_instance_);
}
inline const ::CMsgQAngle& CNETMsg_SpawnGroup_Load::world_offset_angle() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.world_offset_angle)
  return _internal_world_offset_angle();
}
inline void CNETMsg_SpawnGroup_Load::unsafe_arena_set_allocated_world_offset_angle(
    ::CMsgQAngle* world_offset_angle) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.world_offset_angle_);
  }
  _impl_.world_offset_angle_ = world_offset_angle;
  if (world_offset_angle) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CNETMsg_SpawnGroup_Load.world_offset_angle)
}
inline ::CMsgQAngle* CNETMsg_SpawnGroup_Load::release_world_offset_angle() {
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::CMsgQAngle* temp = _impl_.world_offset_angle_;
  _impl_.world_offset_angle_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgQAngle* CNETMsg_SpawnGroup_Load::unsafe_arena_release_world_offset_angle() {
  // @@protoc_insertion_point(field_release:CNETMsg_SpawnGroup_Load.world_offset_angle)
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::CMsgQAngle* temp = _impl_.world_offset_angle_;
  _impl_.world_offset_angle_ = nullptr;
  return temp;
}
inline ::CMsgQAngle* CNETMsg_SpawnGroup_Load::_internal_mutable_world_offset_angle() {
  _impl_._has_bits_[0] |= 0x00000200u;
  if (_impl_.world_offset_angle_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgQAngle>(GetArenaForAllocation());
    _impl_.world_offset_angle_ = p;
  }
  return _impl_.world_offset_angle_;
}
inline ::CMsgQAngle* CNETMsg_SpawnGroup_Load::mutable_world_offset_angle() {
  ::CMsgQAngle* _msg = _internal_mutable_world_offset_angle();
  // @@protoc_insertion_point(field_mutable:CNETMsg_SpawnGroup_Load.world_offset_angle)
  return _msg;
}
inline void CNETMsg_SpawnGroup_Load::set_allocated_world_offset_angle(::CMsgQAngle* world_offset_angle) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.world_offset_angle_;
  }
  if (world_offset_angle) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(world_offset_angle);
    if (message_arena != submessage_arena) {
      world_offset_angle = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, world_offset_angle, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.world_offset_angle_ = world_offset_angle;
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_SpawnGroup_Load.world_offset_angle)
}

// optional bytes spawngroupmanifest = 8;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_spawngroupmanifest() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_spawngroupmanifest() const {
  return _internal_has_spawngroupmanifest();
}
inline void CNETMsg_SpawnGroup_Load::clear_spawngroupmanifest() {
  _impl_.spawngroupmanifest_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& CNETMsg_SpawnGroup_Load::spawngroupmanifest() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.spawngroupmanifest)
  return _internal_spawngroupmanifest();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CNETMsg_SpawnGroup_Load::set_spawngroupmanifest(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.spawngroupmanifest_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.spawngroupmanifest)
}
inline std::string* CNETMsg_SpawnGroup_Load::mutable_spawngroupmanifest() {
  std::string* _s = _internal_mutable_spawngroupmanifest();
  // @@protoc_insertion_point(field_mutable:CNETMsg_SpawnGroup_Load.spawngroupmanifest)
  return _s;
}
inline const std::string& CNETMsg_SpawnGroup_Load::_internal_spawngroupmanifest() const {
  return _impl_.spawngroupmanifest_.Get();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_spawngroupmanifest(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.spawngroupmanifest_.Set(value, GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::_internal_mutable_spawngroupmanifest() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.spawngroupmanifest_.Mutable(GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::release_spawngroupmanifest() {
  // @@protoc_insertion_point(field_release:CNETMsg_SpawnGroup_Load.spawngroupmanifest)
  if (!_internal_has_spawngroupmanifest()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.spawngroupmanifest_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.spawngroupmanifest_.IsDefault()) {
    _impl_.spawngroupmanifest_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CNETMsg_SpawnGroup_Load::set_allocated_spawngroupmanifest(std::string* spawngroupmanifest) {
  if (spawngroupmanifest != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.spawngroupmanifest_.SetAllocated(spawngroupmanifest, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.spawngroupmanifest_.IsDefault()) {
    _impl_.spawngroupmanifest_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_SpawnGroup_Load.spawngroupmanifest)
}

// optional uint32 flags = 9;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_flags() const {
  return _internal_has_flags();
}
inline void CNETMsg_SpawnGroup_Load::clear_flags() {
  _impl_.flags_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t CNETMsg_SpawnGroup_Load::_internal_flags() const {
  return _impl_.flags_;
}
inline uint32_t CNETMsg_SpawnGroup_Load::flags() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.flags)
  return _internal_flags();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_flags(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.flags_ = value;
}
inline void CNETMsg_SpawnGroup_Load::set_flags(uint32_t value) {
  _internal_set_flags(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.flags)
}

// optional int32 tickcount = 10;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_tickcount() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_tickcount() const {
  return _internal_has_tickcount();
}
inline void CNETMsg_SpawnGroup_Load::clear_tickcount() {
  _impl_.tickcount_ = 0;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline int32_t CNETMsg_SpawnGroup_Load::_internal_tickcount() const {
  return _impl_.tickcount_;
}
inline int32_t CNETMsg_SpawnGroup_Load::tickcount() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.tickcount)
  return _internal_tickcount();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_tickcount(int32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.tickcount_ = value;
}
inline void CNETMsg_SpawnGroup_Load::set_tickcount(int32_t value) {
  _internal_set_tickcount(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.tickcount)
}

// optional bool manifestincomplete = 11;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_manifestincomplete() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_manifestincomplete() const {
  return _internal_has_manifestincomplete();
}
inline void CNETMsg_SpawnGroup_Load::clear_manifestincomplete() {
  _impl_.manifestincomplete_ = false;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline bool CNETMsg_SpawnGroup_Load::_internal_manifestincomplete() const {
  return _impl_.manifestincomplete_;
}
inline bool CNETMsg_SpawnGroup_Load::manifestincomplete() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.manifestincomplete)
  return _internal_manifestincomplete();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_manifestincomplete(bool value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.manifestincomplete_ = value;
}
inline void CNETMsg_SpawnGroup_Load::set_manifestincomplete(bool value) {
  _internal_set_manifestincomplete(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.manifestincomplete)
}

// optional string localnamefixup = 12;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_localnamefixup() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_localnamefixup() const {
  return _internal_has_localnamefixup();
}
inline void CNETMsg_SpawnGroup_Load::clear_localnamefixup() {
  _impl_.localnamefixup_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& CNETMsg_SpawnGroup_Load::localnamefixup() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.localnamefixup)
  return _internal_localnamefixup();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CNETMsg_SpawnGroup_Load::set_localnamefixup(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.localnamefixup_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.localnamefixup)
}
inline std::string* CNETMsg_SpawnGroup_Load::mutable_localnamefixup() {
  std::string* _s = _internal_mutable_localnamefixup();
  // @@protoc_insertion_point(field_mutable:CNETMsg_SpawnGroup_Load.localnamefixup)
  return _s;
}
inline const std::string& CNETMsg_SpawnGroup_Load::_internal_localnamefixup() const {
  return _impl_.localnamefixup_.Get();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_localnamefixup(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.localnamefixup_.Set(value, GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::_internal_mutable_localnamefixup() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.localnamefixup_.Mutable(GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::release_localnamefixup() {
  // @@protoc_insertion_point(field_release:CNETMsg_SpawnGroup_Load.localnamefixup)
  if (!_internal_has_localnamefixup()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.localnamefixup_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localnamefixup_.IsDefault()) {
    _impl_.localnamefixup_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CNETMsg_SpawnGroup_Load::set_allocated_localnamefixup(std::string* localnamefixup) {
  if (localnamefixup != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.localnamefixup_.SetAllocated(localnamefixup, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localnamefixup_.IsDefault()) {
    _impl_.localnamefixup_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_SpawnGroup_Load.localnamefixup)
}

// optional string parentnamefixup = 13;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_parentnamefixup() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_parentnamefixup() const {
  return _internal_has_parentnamefixup();
}
inline void CNETMsg_SpawnGroup_Load::clear_parentnamefixup() {
  _impl_.parentnamefixup_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& CNETMsg_SpawnGroup_Load::parentnamefixup() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.parentnamefixup)
  return _internal_parentnamefixup();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CNETMsg_SpawnGroup_Load::set_parentnamefixup(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.parentnamefixup_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.parentnamefixup)
}
inline std::string* CNETMsg_SpawnGroup_Load::mutable_parentnamefixup() {
  std::string* _s = _internal_mutable_parentnamefixup();
  // @@protoc_insertion_point(field_mutable:CNETMsg_SpawnGroup_Load.parentnamefixup)
  return _s;
}
inline const std::string& CNETMsg_SpawnGroup_Load::_internal_parentnamefixup() const {
  return _impl_.parentnamefixup_.Get();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_parentnamefixup(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.parentnamefixup_.Set(value, GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::_internal_mutable_parentnamefixup() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.parentnamefixup_.Mutable(GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::release_parentnamefixup() {
  // @@protoc_insertion_point(field_release:CNETMsg_SpawnGroup_Load.parentnamefixup)
  if (!_internal_has_parentnamefixup()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.parentnamefixup_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.parentnamefixup_.IsDefault()) {
    _impl_.parentnamefixup_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CNETMsg_SpawnGroup_Load::set_allocated_parentnamefixup(std::string* parentnamefixup) {
  if (parentnamefixup != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.parentnamefixup_.SetAllocated(parentnamefixup, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.parentnamefixup_.IsDefault()) {
    _impl_.parentnamefixup_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_SpawnGroup_Load.parentnamefixup)
}

// optional int32 manifestloadpriority = 14;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_manifestloadpriority() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_manifestloadpriority() const {
  return _internal_has_manifestloadpriority();
}
inline void CNETMsg_SpawnGroup_Load::clear_manifestloadpriority() {
  _impl_.manifestloadpriority_ = 0;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline int32_t CNETMsg_SpawnGroup_Load::_internal_manifestloadpriority() const {
  return _impl_.manifestloadpriority_;
}
inline int32_t CNETMsg_SpawnGroup_Load::manifestloadpriority() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.manifestloadpriority)
  return _internal_manifestloadpriority();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_manifestloadpriority(int32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.manifestloadpriority_ = value;
}
inline void CNETMsg_SpawnGroup_Load::set_manifestloadpriority(int32_t value) {
  _internal_set_manifestloadpriority(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.manifestloadpriority)
}

// optional uint32 worldgroupid = 15;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_worldgroupid() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_worldgroupid() const {
  return _internal_has_worldgroupid();
}
inline void CNETMsg_SpawnGroup_Load::clear_worldgroupid() {
  _impl_.worldgroupid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline uint32_t CNETMsg_SpawnGroup_Load::_internal_worldgroupid() const {
  return _impl_.worldgroupid_;
}
inline uint32_t CNETMsg_SpawnGroup_Load::worldgroupid() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.worldgroupid)
  return _internal_worldgroupid();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_worldgroupid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.worldgroupid_ = value;
}
inline void CNETMsg_SpawnGroup_Load::set_worldgroupid(uint32_t value) {
  _internal_set_worldgroupid(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.worldgroupid)
}

// optional uint32 creationsequence = 16;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_creationsequence() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_creationsequence() const {
  return _internal_has_creationsequence();
}
inline void CNETMsg_SpawnGroup_Load::clear_creationsequence() {
  _impl_.creationsequence_ = 0u;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline uint32_t CNETMsg_SpawnGroup_Load::_internal_creationsequence() const {
  return _impl_.creationsequence_;
}
inline uint32_t CNETMsg_SpawnGroup_Load::creationsequence() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.creationsequence)
  return _internal_creationsequence();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_creationsequence(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.creationsequence_ = value;
}
inline void CNETMsg_SpawnGroup_Load::set_creationsequence(uint32_t value) {
  _internal_set_creationsequence(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.creationsequence)
}

// optional string savegamefilename = 17;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_savegamefilename() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_savegamefilename() const {
  return _internal_has_savegamefilename();
}
inline void CNETMsg_SpawnGroup_Load::clear_savegamefilename() {
  _impl_.savegamefilename_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& CNETMsg_SpawnGroup_Load::savegamefilename() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.savegamefilename)
  return _internal_savegamefilename();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CNETMsg_SpawnGroup_Load::set_savegamefilename(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.savegamefilename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.savegamefilename)
}
inline std::string* CNETMsg_SpawnGroup_Load::mutable_savegamefilename() {
  std::string* _s = _internal_mutable_savegamefilename();
  // @@protoc_insertion_point(field_mutable:CNETMsg_SpawnGroup_Load.savegamefilename)
  return _s;
}
inline const std::string& CNETMsg_SpawnGroup_Load::_internal_savegamefilename() const {
  return _impl_.savegamefilename_.Get();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_savegamefilename(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.savegamefilename_.Set(value, GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::_internal_mutable_savegamefilename() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.savegamefilename_.Mutable(GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::release_savegamefilename() {
  // @@protoc_insertion_point(field_release:CNETMsg_SpawnGroup_Load.savegamefilename)
  if (!_internal_has_savegamefilename()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.savegamefilename_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.savegamefilename_.IsDefault()) {
    _impl_.savegamefilename_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CNETMsg_SpawnGroup_Load::set_allocated_savegamefilename(std::string* savegamefilename) {
  if (savegamefilename != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.savegamefilename_.SetAllocated(savegamefilename, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.savegamefilename_.IsDefault()) {
    _impl_.savegamefilename_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_SpawnGroup_Load.savegamefilename)
}

// optional uint32 spawngroupparenthandle = 18;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_spawngroupparenthandle() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_spawngroupparenthandle() const {
  return _internal_has_spawngroupparenthandle();
}
inline void CNETMsg_SpawnGroup_Load::clear_spawngroupparenthandle() {
  _impl_.spawngroupparenthandle_ = 0u;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline uint32_t CNETMsg_SpawnGroup_Load::_internal_spawngroupparenthandle() const {
  return _impl_.spawngroupparenthandle_;
}
inline uint32_t CNETMsg_SpawnGroup_Load::spawngroupparenthandle() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.spawngroupparenthandle)
  return _internal_spawngroupparenthandle();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_spawngroupparenthandle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.spawngroupparenthandle_ = value;
}
inline void CNETMsg_SpawnGroup_Load::set_spawngroupparenthandle(uint32_t value) {
  _internal_set_spawngroupparenthandle(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.spawngroupparenthandle)
}

// optional bool leveltransition = 19;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_leveltransition() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_leveltransition() const {
  return _internal_has_leveltransition();
}
inline void CNETMsg_SpawnGroup_Load::clear_leveltransition() {
  _impl_.leveltransition_ = false;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline bool CNETMsg_SpawnGroup_Load::_internal_leveltransition() const {
  return _impl_.leveltransition_;
}
inline bool CNETMsg_SpawnGroup_Load::leveltransition() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.leveltransition)
  return _internal_leveltransition();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_leveltransition(bool value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.leveltransition_ = value;
}
inline void CNETMsg_SpawnGroup_Load::set_leveltransition(bool value) {
  _internal_set_leveltransition(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.leveltransition)
}

// optional string worldgroupname = 20;
inline bool CNETMsg_SpawnGroup_Load::_internal_has_worldgroupname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Load::has_worldgroupname() const {
  return _internal_has_worldgroupname();
}
inline void CNETMsg_SpawnGroup_Load::clear_worldgroupname() {
  _impl_.worldgroupname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& CNETMsg_SpawnGroup_Load::worldgroupname() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Load.worldgroupname)
  return _internal_worldgroupname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CNETMsg_SpawnGroup_Load::set_worldgroupname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.worldgroupname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Load.worldgroupname)
}
inline std::string* CNETMsg_SpawnGroup_Load::mutable_worldgroupname() {
  std::string* _s = _internal_mutable_worldgroupname();
  // @@protoc_insertion_point(field_mutable:CNETMsg_SpawnGroup_Load.worldgroupname)
  return _s;
}
inline const std::string& CNETMsg_SpawnGroup_Load::_internal_worldgroupname() const {
  return _impl_.worldgroupname_.Get();
}
inline void CNETMsg_SpawnGroup_Load::_internal_set_worldgroupname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.worldgroupname_.Set(value, GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::_internal_mutable_worldgroupname() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.worldgroupname_.Mutable(GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_Load::release_worldgroupname() {
  // @@protoc_insertion_point(field_release:CNETMsg_SpawnGroup_Load.worldgroupname)
  if (!_internal_has_worldgroupname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.worldgroupname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.worldgroupname_.IsDefault()) {
    _impl_.worldgroupname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CNETMsg_SpawnGroup_Load::set_allocated_worldgroupname(std::string* worldgroupname) {
  if (worldgroupname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.worldgroupname_.SetAllocated(worldgroupname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.worldgroupname_.IsDefault()) {
    _impl_.worldgroupname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_SpawnGroup_Load.worldgroupname)
}

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

// CNETMsg_SpawnGroup_ManifestUpdate

// optional uint32 spawngrouphandle = 1;
inline bool CNETMsg_SpawnGroup_ManifestUpdate::_internal_has_spawngrouphandle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_ManifestUpdate::has_spawngrouphandle() const {
  return _internal_has_spawngrouphandle();
}
inline void CNETMsg_SpawnGroup_ManifestUpdate::clear_spawngrouphandle() {
  _impl_.spawngrouphandle_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CNETMsg_SpawnGroup_ManifestUpdate::_internal_spawngrouphandle() const {
  return _impl_.spawngrouphandle_;
}
inline uint32_t CNETMsg_SpawnGroup_ManifestUpdate::spawngrouphandle() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_ManifestUpdate.spawngrouphandle)
  return _internal_spawngrouphandle();
}
inline void CNETMsg_SpawnGroup_ManifestUpdate::_internal_set_spawngrouphandle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.spawngrouphandle_ = value;
}
inline void CNETMsg_SpawnGroup_ManifestUpdate::set_spawngrouphandle(uint32_t value) {
  _internal_set_spawngrouphandle(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_ManifestUpdate.spawngrouphandle)
}

// optional bytes spawngroupmanifest = 2;
inline bool CNETMsg_SpawnGroup_ManifestUpdate::_internal_has_spawngroupmanifest() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_ManifestUpdate::has_spawngroupmanifest() const {
  return _internal_has_spawngroupmanifest();
}
inline void CNETMsg_SpawnGroup_ManifestUpdate::clear_spawngroupmanifest() {
  _impl_.spawngroupmanifest_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CNETMsg_SpawnGroup_ManifestUpdate::spawngroupmanifest() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_ManifestUpdate.spawngroupmanifest)
  return _internal_spawngroupmanifest();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CNETMsg_SpawnGroup_ManifestUpdate::set_spawngroupmanifest(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.spawngroupmanifest_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_ManifestUpdate.spawngroupmanifest)
}
inline std::string* CNETMsg_SpawnGroup_ManifestUpdate::mutable_spawngroupmanifest() {
  std::string* _s = _internal_mutable_spawngroupmanifest();
  // @@protoc_insertion_point(field_mutable:CNETMsg_SpawnGroup_ManifestUpdate.spawngroupmanifest)
  return _s;
}
inline const std::string& CNETMsg_SpawnGroup_ManifestUpdate::_internal_spawngroupmanifest() const {
  return _impl_.spawngroupmanifest_.Get();
}
inline void CNETMsg_SpawnGroup_ManifestUpdate::_internal_set_spawngroupmanifest(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.spawngroupmanifest_.Set(value, GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_ManifestUpdate::_internal_mutable_spawngroupmanifest() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.spawngroupmanifest_.Mutable(GetArenaForAllocation());
}
inline std::string* CNETMsg_SpawnGroup_ManifestUpdate::release_spawngroupmanifest() {
  // @@protoc_insertion_point(field_release:CNETMsg_SpawnGroup_ManifestUpdate.spawngroupmanifest)
  if (!_internal_has_spawngroupmanifest()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.spawngroupmanifest_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.spawngroupmanifest_.IsDefault()) {
    _impl_.spawngroupmanifest_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CNETMsg_SpawnGroup_ManifestUpdate::set_allocated_spawngroupmanifest(std::string* spawngroupmanifest) {
  if (spawngroupmanifest != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.spawngroupmanifest_.SetAllocated(spawngroupmanifest, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.spawngroupmanifest_.IsDefault()) {
    _impl_.spawngroupmanifest_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CNETMsg_SpawnGroup_ManifestUpdate.spawngroupmanifest)
}

// optional bool manifestincomplete = 3;
inline bool CNETMsg_SpawnGroup_ManifestUpdate::_internal_has_manifestincomplete() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_ManifestUpdate::has_manifestincomplete() const {
  return _internal_has_manifestincomplete();
}
inline void CNETMsg_SpawnGroup_ManifestUpdate::clear_manifestincomplete() {
  _impl_.manifestincomplete_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CNETMsg_SpawnGroup_ManifestUpdate::_internal_manifestincomplete() const {
  return _impl_.manifestincomplete_;
}
inline bool CNETMsg_SpawnGroup_ManifestUpdate::manifestincomplete() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_ManifestUpdate.manifestincomplete)
  return _internal_manifestincomplete();
}
inline void CNETMsg_SpawnGroup_ManifestUpdate::_internal_set_manifestincomplete(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.manifestincomplete_ = value;
}
inline void CNETMsg_SpawnGroup_ManifestUpdate::set_manifestincomplete(bool value) {
  _internal_set_manifestincomplete(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_ManifestUpdate.manifestincomplete)
}

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

// CNETMsg_SpawnGroup_SetCreationTick

// optional uint32 spawngrouphandle = 1;
inline bool CNETMsg_SpawnGroup_SetCreationTick::_internal_has_spawngrouphandle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_SetCreationTick::has_spawngrouphandle() const {
  return _internal_has_spawngrouphandle();
}
inline void CNETMsg_SpawnGroup_SetCreationTick::clear_spawngrouphandle() {
  _impl_.spawngrouphandle_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CNETMsg_SpawnGroup_SetCreationTick::_internal_spawngrouphandle() const {
  return _impl_.spawngrouphandle_;
}
inline uint32_t CNETMsg_SpawnGroup_SetCreationTick::spawngrouphandle() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_SetCreationTick.spawngrouphandle)
  return _internal_spawngrouphandle();
}
inline void CNETMsg_SpawnGroup_SetCreationTick::_internal_set_spawngrouphandle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.spawngrouphandle_ = value;
}
inline void CNETMsg_SpawnGroup_SetCreationTick::set_spawngrouphandle(uint32_t value) {
  _internal_set_spawngrouphandle(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_SetCreationTick.spawngrouphandle)
}

// optional int32 tickcount = 2;
inline bool CNETMsg_SpawnGroup_SetCreationTick::_internal_has_tickcount() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_SetCreationTick::has_tickcount() const {
  return _internal_has_tickcount();
}
inline void CNETMsg_SpawnGroup_SetCreationTick::clear_tickcount() {
  _impl_.tickcount_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CNETMsg_SpawnGroup_SetCreationTick::_internal_tickcount() const {
  return _impl_.tickcount_;
}
inline int32_t CNETMsg_SpawnGroup_SetCreationTick::tickcount() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_SetCreationTick.tickcount)
  return _internal_tickcount();
}
inline void CNETMsg_SpawnGroup_SetCreationTick::_internal_set_tickcount(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.tickcount_ = value;
}
inline void CNETMsg_SpawnGroup_SetCreationTick::set_tickcount(int32_t value) {
  _internal_set_tickcount(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_SetCreationTick.tickcount)
}

// optional uint32 creationsequence = 3;
inline bool CNETMsg_SpawnGroup_SetCreationTick::_internal_has_creationsequence() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_SetCreationTick::has_creationsequence() const {
  return _internal_has_creationsequence();
}
inline void CNETMsg_SpawnGroup_SetCreationTick::clear_creationsequence() {
  _impl_.creationsequence_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CNETMsg_SpawnGroup_SetCreationTick::_internal_creationsequence() const {
  return _impl_.creationsequence_;
}
inline uint32_t CNETMsg_SpawnGroup_SetCreationTick::creationsequence() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_SetCreationTick.creationsequence)
  return _internal_creationsequence();
}
inline void CNETMsg_SpawnGroup_SetCreationTick::_internal_set_creationsequence(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.creationsequence_ = value;
}
inline void CNETMsg_SpawnGroup_SetCreationTick::set_creationsequence(uint32_t value) {
  _internal_set_creationsequence(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_SetCreationTick.creationsequence)
}

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

// CNETMsg_SpawnGroup_Unload

// optional uint32 spawngrouphandle = 1;
inline bool CNETMsg_SpawnGroup_Unload::_internal_has_spawngrouphandle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Unload::has_spawngrouphandle() const {
  return _internal_has_spawngrouphandle();
}
inline void CNETMsg_SpawnGroup_Unload::clear_spawngrouphandle() {
  _impl_.spawngrouphandle_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CNETMsg_SpawnGroup_Unload::_internal_spawngrouphandle() const {
  return _impl_.spawngrouphandle_;
}
inline uint32_t CNETMsg_SpawnGroup_Unload::spawngrouphandle() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Unload.spawngrouphandle)
  return _internal_spawngrouphandle();
}
inline void CNETMsg_SpawnGroup_Unload::_internal_set_spawngrouphandle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.spawngrouphandle_ = value;
}
inline void CNETMsg_SpawnGroup_Unload::set_spawngrouphandle(uint32_t value) {
  _internal_set_spawngrouphandle(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Unload.spawngrouphandle)
}

// optional uint32 flags = 2;
inline bool CNETMsg_SpawnGroup_Unload::_internal_has_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Unload::has_flags() const {
  return _internal_has_flags();
}
inline void CNETMsg_SpawnGroup_Unload::clear_flags() {
  _impl_.flags_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CNETMsg_SpawnGroup_Unload::_internal_flags() const {
  return _impl_.flags_;
}
inline uint32_t CNETMsg_SpawnGroup_Unload::flags() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Unload.flags)
  return _internal_flags();
}
inline void CNETMsg_SpawnGroup_Unload::_internal_set_flags(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.flags_ = value;
}
inline void CNETMsg_SpawnGroup_Unload::set_flags(uint32_t value) {
  _internal_set_flags(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Unload.flags)
}

// optional int32 tickcount = 3;
inline bool CNETMsg_SpawnGroup_Unload::_internal_has_tickcount() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_Unload::has_tickcount() const {
  return _internal_has_tickcount();
}
inline void CNETMsg_SpawnGroup_Unload::clear_tickcount() {
  _impl_.tickcount_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CNETMsg_SpawnGroup_Unload::_internal_tickcount() const {
  return _impl_.tickcount_;
}
inline int32_t CNETMsg_SpawnGroup_Unload::tickcount() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_Unload.tickcount)
  return _internal_tickcount();
}
inline void CNETMsg_SpawnGroup_Unload::_internal_set_tickcount(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.tickcount_ = value;
}
inline void CNETMsg_SpawnGroup_Unload::set_tickcount(int32_t value) {
  _internal_set_tickcount(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_Unload.tickcount)
}

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

// CNETMsg_SpawnGroup_LoadCompleted

// optional uint32 spawngrouphandle = 1;
inline bool CNETMsg_SpawnGroup_LoadCompleted::_internal_has_spawngrouphandle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CNETMsg_SpawnGroup_LoadCompleted::has_spawngrouphandle() const {
  return _internal_has_spawngrouphandle();
}
inline void CNETMsg_SpawnGroup_LoadCompleted::clear_spawngrouphandle() {
  _impl_.spawngrouphandle_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CNETMsg_SpawnGroup_LoadCompleted::_internal_spawngrouphandle() const {
  return _impl_.spawngrouphandle_;
}
inline uint32_t CNETMsg_SpawnGroup_LoadCompleted::spawngrouphandle() const {
  // @@protoc_insertion_point(field_get:CNETMsg_SpawnGroup_LoadCompleted.spawngrouphandle)
  return _internal_spawngrouphandle();
}
inline void CNETMsg_SpawnGroup_LoadCompleted::_internal_set_spawngrouphandle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.spawngrouphandle_ = value;
}
inline void CNETMsg_SpawnGroup_LoadCompleted::set_spawngrouphandle(uint32_t value) {
  _internal_set_spawngrouphandle(value);
  // @@protoc_insertion_point(field_set:CNETMsg_SpawnGroup_LoadCompleted.spawngrouphandle)
}

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

// CSVCMsg_GameSessionConfiguration

// optional bool is_multiplayer = 1;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_is_multiplayer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_is_multiplayer() const {
  return _internal_has_is_multiplayer();
}
inline void CSVCMsg_GameSessionConfiguration::clear_is_multiplayer() {
  _impl_.is_multiplayer_ = false;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline bool CSVCMsg_GameSessionConfiguration::_internal_is_multiplayer() const {
  return _impl_.is_multiplayer_;
}
inline bool CSVCMsg_GameSessionConfiguration::is_multiplayer() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.is_multiplayer)
  return _internal_is_multiplayer();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_is_multiplayer(bool value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.is_multiplayer_ = value;
}
inline void CSVCMsg_GameSessionConfiguration::set_is_multiplayer(bool value) {
  _internal_set_is_multiplayer(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.is_multiplayer)
}

// optional bool is_loadsavegame = 2;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_is_loadsavegame() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_is_loadsavegame() const {
  return _internal_has_is_loadsavegame();
}
inline void CSVCMsg_GameSessionConfiguration::clear_is_loadsavegame() {
  _impl_.is_loadsavegame_ = false;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline bool CSVCMsg_GameSessionConfiguration::_internal_is_loadsavegame() const {
  return _impl_.is_loadsavegame_;
}
inline bool CSVCMsg_GameSessionConfiguration::is_loadsavegame() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.is_loadsavegame)
  return _internal_is_loadsavegame();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_is_loadsavegame(bool value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.is_loadsavegame_ = value;
}
inline void CSVCMsg_GameSessionConfiguration::set_is_loadsavegame(bool value) {
  _internal_set_is_loadsavegame(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.is_loadsavegame)
}

// optional bool is_background_map = 3;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_is_background_map() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_is_background_map() const {
  return _internal_has_is_background_map();
}
inline void CSVCMsg_GameSessionConfiguration::clear_is_background_map() {
  _impl_.is_background_map_ = false;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline bool CSVCMsg_GameSessionConfiguration::_internal_is_background_map() const {
  return _impl_.is_background_map_;
}
inline bool CSVCMsg_GameSessionConfiguration::is_background_map() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.is_background_map)
  return _internal_is_background_map();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_is_background_map(bool value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.is_background_map_ = value;
}
inline void CSVCMsg_GameSessionConfiguration::set_is_background_map(bool value) {
  _internal_set_is_background_map(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.is_background_map)
}

// optional bool is_headless = 4;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_is_headless() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_is_headless() const {
  return _internal_has_is_headless();
}
inline void CSVCMsg_GameSessionConfiguration::clear_is_headless() {
  _impl_.is_headless_ = false;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline bool CSVCMsg_GameSessionConfiguration::_internal_is_headless() const {
  return _impl_.is_headless_;
}
inline bool CSVCMsg_GameSessionConfiguration::is_headless() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.is_headless)
  return _internal_is_headless();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_is_headless(bool value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.is_headless_ = value;
}
inline void CSVCMsg_GameSessionConfiguration::set_is_headless(bool value) {
  _internal_set_is_headless(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.is_headless)
}

// optional uint32 min_client_limit = 5;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_min_client_limit() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_min_client_limit() const {
  return _internal_has_min_client_limit();
}
inline void CSVCMsg_GameSessionConfiguration::clear_min_client_limit() {
  _impl_.min_client_limit_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t CSVCMsg_GameSessionConfiguration::_internal_min_client_limit() const {
  return _impl_.min_client_limit_;
}
inline uint32_t CSVCMsg_GameSessionConfiguration::min_client_limit() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.min_client_limit)
  return _internal_min_client_limit();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_min_client_limit(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.min_client_limit_ = value;
}
inline void CSVCMsg_GameSessionConfiguration::set_min_client_limit(uint32_t value) {
  _internal_set_min_client_limit(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.min_client_limit)
}

// optional uint32 max_client_limit = 6;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_max_client_limit() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_max_client_limit() const {
  return _internal_has_max_client_limit();
}
inline void CSVCMsg_GameSessionConfiguration::clear_max_client_limit() {
  _impl_.max_client_limit_ = 0u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t CSVCMsg_GameSessionConfiguration::_internal_max_client_limit() const {
  return _impl_.max_client_limit_;
}
inline uint32_t CSVCMsg_GameSessionConfiguration::max_client_limit() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.max_client_limit)
  return _internal_max_client_limit();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_max_client_limit(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.max_client_limit_ = value;
}
inline void CSVCMsg_GameSessionConfiguration::set_max_client_limit(uint32_t value) {
  _internal_set_max_client_limit(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.max_client_limit)
}

// optional uint32 max_clients = 7;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_max_clients() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_max_clients() const {
  return _internal_has_max_clients();
}
inline void CSVCMsg_GameSessionConfiguration::clear_max_clients() {
  _impl_.max_clients_ = 0u;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint32_t CSVCMsg_GameSessionConfiguration::_internal_max_clients() const {
  return _impl_.max_clients_;
}
inline uint32_t CSVCMsg_GameSessionConfiguration::max_clients() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.max_clients)
  return _internal_max_clients();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_max_clients(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.max_clients_ = value;
}
inline void CSVCMsg_GameSessionConfiguration::set_max_clients(uint32_t value) {
  _internal_set_max_clients(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.max_clients)
}

// optional fixed32 tick_interval = 8;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_tick_interval() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_tick_interval() const {
  return _internal_has_tick_interval();
}
inline void CSVCMsg_GameSessionConfiguration::clear_tick_interval() {
  _impl_.tick_interval_ = 0u;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline uint32_t CSVCMsg_GameSessionConfiguration::_internal_tick_interval() const {
  return _impl_.tick_interval_;
}
inline uint32_t CSVCMsg_GameSessionConfiguration::tick_interval() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.tick_interval)
  return _internal_tick_interval();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_tick_interval(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.tick_interval_ = value;
}
inline void CSVCMsg_GameSessionConfiguration::set_tick_interval(uint32_t value) {
  _internal_set_tick_interval(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.tick_interval)
}

// optional string hostname = 9;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_hostname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_hostname() const {
  return _internal_has_hostname();
}
inline void CSVCMsg_GameSessionConfiguration::clear_hostname() {
  _impl_.hostname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::hostname() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.hostname)
  return _internal_hostname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_GameSessionConfiguration::set_hostname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.hostname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.hostname)
}
inline std::string* CSVCMsg_GameSessionConfiguration::mutable_hostname() {
  std::string* _s = _internal_mutable_hostname();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GameSessionConfiguration.hostname)
  return _s;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::_internal_hostname() const {
  return _impl_.hostname_.Get();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_hostname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.hostname_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::_internal_mutable_hostname() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.hostname_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::release_hostname() {
  // @@protoc_insertion_point(field_release:CSVCMsg_GameSessionConfiguration.hostname)
  if (!_internal_has_hostname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.hostname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.hostname_.IsDefault()) {
    _impl_.hostname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_GameSessionConfiguration::set_allocated_hostname(std::string* hostname) {
  if (hostname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.hostname_.SetAllocated(hostname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.hostname_.IsDefault()) {
    _impl_.hostname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_GameSessionConfiguration.hostname)
}

// optional string savegamename = 10;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_savegamename() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_savegamename() const {
  return _internal_has_savegamename();
}
inline void CSVCMsg_GameSessionConfiguration::clear_savegamename() {
  _impl_.savegamename_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::savegamename() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.savegamename)
  return _internal_savegamename();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_GameSessionConfiguration::set_savegamename(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.savegamename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.savegamename)
}
inline std::string* CSVCMsg_GameSessionConfiguration::mutable_savegamename() {
  std::string* _s = _internal_mutable_savegamename();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GameSessionConfiguration.savegamename)
  return _s;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::_internal_savegamename() const {
  return _impl_.savegamename_.Get();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_savegamename(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.savegamename_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::_internal_mutable_savegamename() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.savegamename_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::release_savegamename() {
  // @@protoc_insertion_point(field_release:CSVCMsg_GameSessionConfiguration.savegamename)
  if (!_internal_has_savegamename()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.savegamename_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.savegamename_.IsDefault()) {
    _impl_.savegamename_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_GameSessionConfiguration::set_allocated_savegamename(std::string* savegamename) {
  if (savegamename != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.savegamename_.SetAllocated(savegamename, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.savegamename_.IsDefault()) {
    _impl_.savegamename_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_GameSessionConfiguration.savegamename)
}

// optional string s1_mapname = 11;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_s1_mapname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_s1_mapname() const {
  return _internal_has_s1_mapname();
}
inline void CSVCMsg_GameSessionConfiguration::clear_s1_mapname() {
  _impl_.s1_mapname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::s1_mapname() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.s1_mapname)
  return _internal_s1_mapname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_GameSessionConfiguration::set_s1_mapname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.s1_mapname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.s1_mapname)
}
inline std::string* CSVCMsg_GameSessionConfiguration::mutable_s1_mapname() {
  std::string* _s = _internal_mutable_s1_mapname();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GameSessionConfiguration.s1_mapname)
  return _s;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::_internal_s1_mapname() const {
  return _impl_.s1_mapname_.Get();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_s1_mapname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.s1_mapname_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::_internal_mutable_s1_mapname() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.s1_mapname_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::release_s1_mapname() {
  // @@protoc_insertion_point(field_release:CSVCMsg_GameSessionConfiguration.s1_mapname)
  if (!_internal_has_s1_mapname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.s1_mapname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.s1_mapname_.IsDefault()) {
    _impl_.s1_mapname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_GameSessionConfiguration::set_allocated_s1_mapname(std::string* s1_mapname) {
  if (s1_mapname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.s1_mapname_.SetAllocated(s1_mapname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.s1_mapname_.IsDefault()) {
    _impl_.s1_mapname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_GameSessionConfiguration.s1_mapname)
}

// optional string gamemode = 12;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_gamemode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_gamemode() const {
  return _internal_has_gamemode();
}
inline void CSVCMsg_GameSessionConfiguration::clear_gamemode() {
  _impl_.gamemode_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::gamemode() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.gamemode)
  return _internal_gamemode();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_GameSessionConfiguration::set_gamemode(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.gamemode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.gamemode)
}
inline std::string* CSVCMsg_GameSessionConfiguration::mutable_gamemode() {
  std::string* _s = _internal_mutable_gamemode();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GameSessionConfiguration.gamemode)
  return _s;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::_internal_gamemode() const {
  return _impl_.gamemode_.Get();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_gamemode(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.gamemode_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::_internal_mutable_gamemode() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.gamemode_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::release_gamemode() {
  // @@protoc_insertion_point(field_release:CSVCMsg_GameSessionConfiguration.gamemode)
  if (!_internal_has_gamemode()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.gamemode_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.gamemode_.IsDefault()) {
    _impl_.gamemode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_GameSessionConfiguration::set_allocated_gamemode(std::string* gamemode) {
  if (gamemode != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.gamemode_.SetAllocated(gamemode, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.gamemode_.IsDefault()) {
    _impl_.gamemode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_GameSessionConfiguration.gamemode)
}

// optional string server_ip_address = 13;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_server_ip_address() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_server_ip_address() const {
  return _internal_has_server_ip_address();
}
inline void CSVCMsg_GameSessionConfiguration::clear_server_ip_address() {
  _impl_.server_ip_address_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::server_ip_address() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.server_ip_address)
  return _internal_server_ip_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_GameSessionConfiguration::set_server_ip_address(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.server_ip_address_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.server_ip_address)
}
inline std::string* CSVCMsg_GameSessionConfiguration::mutable_server_ip_address() {
  std::string* _s = _internal_mutable_server_ip_address();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GameSessionConfiguration.server_ip_address)
  return _s;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::_internal_server_ip_address() const {
  return _impl_.server_ip_address_.Get();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_server_ip_address(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.server_ip_address_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::_internal_mutable_server_ip_address() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.server_ip_address_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::release_server_ip_address() {
  // @@protoc_insertion_point(field_release:CSVCMsg_GameSessionConfiguration.server_ip_address)
  if (!_internal_has_server_ip_address()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.server_ip_address_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.server_ip_address_.IsDefault()) {
    _impl_.server_ip_address_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_GameSessionConfiguration::set_allocated_server_ip_address(std::string* server_ip_address) {
  if (server_ip_address != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.server_ip_address_.SetAllocated(server_ip_address, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.server_ip_address_.IsDefault()) {
    _impl_.server_ip_address_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_GameSessionConfiguration.server_ip_address)
}

// optional bytes data = 14;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_data() const {
  return _internal_has_data();
}
inline void CSVCMsg_GameSessionConfiguration::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::data() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_GameSessionConfiguration::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.data)
}
inline std::string* CSVCMsg_GameSessionConfiguration::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GameSessionConfiguration.data)
  return _s;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::_internal_data() const {
  return _impl_.data_.Get();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::release_data() {
  // @@protoc_insertion_point(field_release:CSVCMsg_GameSessionConfiguration.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_GameSessionConfiguration::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_GameSessionConfiguration.data)
}

// optional bool is_localonly = 15;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_is_localonly() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_is_localonly() const {
  return _internal_has_is_localonly();
}
inline void CSVCMsg_GameSessionConfiguration::clear_is_localonly() {
  _impl_.is_localonly_ = false;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline bool CSVCMsg_GameSessionConfiguration::_internal_is_localonly() const {
  return _impl_.is_localonly_;
}
inline bool CSVCMsg_GameSessionConfiguration::is_localonly() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.is_localonly)
  return _internal_is_localonly();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_is_localonly(bool value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.is_localonly_ = value;
}
inline void CSVCMsg_GameSessionConfiguration::set_is_localonly(bool value) {
  _internal_set_is_localonly(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.is_localonly)
}

// optional bool no_steam_server = 19;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_no_steam_server() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_no_steam_server() const {
  return _internal_has_no_steam_server();
}
inline void CSVCMsg_GameSessionConfiguration::clear_no_steam_server() {
  _impl_.no_steam_server_ = false;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline bool CSVCMsg_GameSessionConfiguration::_internal_no_steam_server() const {
  return _impl_.no_steam_server_;
}
inline bool CSVCMsg_GameSessionConfiguration::no_steam_server() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.no_steam_server)
  return _internal_no_steam_server();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_no_steam_server(bool value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.no_steam_server_ = value;
}
inline void CSVCMsg_GameSessionConfiguration::set_no_steam_server(bool value) {
  _internal_set_no_steam_server(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.no_steam_server)
}

// optional bool is_transition = 16;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_is_transition() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_is_transition() const {
  return _internal_has_is_transition();
}
inline void CSVCMsg_GameSessionConfiguration::clear_is_transition() {
  _impl_.is_transition_ = false;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline bool CSVCMsg_GameSessionConfiguration::_internal_is_transition() const {
  return _impl_.is_transition_;
}
inline bool CSVCMsg_GameSessionConfiguration::is_transition() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.is_transition)
  return _internal_is_transition();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_is_transition(bool value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.is_transition_ = value;
}
inline void CSVCMsg_GameSessionConfiguration::set_is_transition(bool value) {
  _internal_set_is_transition(value);
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.is_transition)
}

// optional string previouslevel = 17;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_previouslevel() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_previouslevel() const {
  return _internal_has_previouslevel();
}
inline void CSVCMsg_GameSessionConfiguration::clear_previouslevel() {
  _impl_.previouslevel_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::previouslevel() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.previouslevel)
  return _internal_previouslevel();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_GameSessionConfiguration::set_previouslevel(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.previouslevel_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.previouslevel)
}
inline std::string* CSVCMsg_GameSessionConfiguration::mutable_previouslevel() {
  std::string* _s = _internal_mutable_previouslevel();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GameSessionConfiguration.previouslevel)
  return _s;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::_internal_previouslevel() const {
  return _impl_.previouslevel_.Get();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_previouslevel(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.previouslevel_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::_internal_mutable_previouslevel() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.previouslevel_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::release_previouslevel() {
  // @@protoc_insertion_point(field_release:CSVCMsg_GameSessionConfiguration.previouslevel)
  if (!_internal_has_previouslevel()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.previouslevel_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.previouslevel_.IsDefault()) {
    _impl_.previouslevel_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_GameSessionConfiguration::set_allocated_previouslevel(std::string* previouslevel) {
  if (previouslevel != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.previouslevel_.SetAllocated(previouslevel, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.previouslevel_.IsDefault()) {
    _impl_.previouslevel_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_GameSessionConfiguration.previouslevel)
}

// optional string landmarkname = 18;
inline bool CSVCMsg_GameSessionConfiguration::_internal_has_landmarkname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CSVCMsg_GameSessionConfiguration::has_landmarkname() const {
  return _internal_has_landmarkname();
}
inline void CSVCMsg_GameSessionConfiguration::clear_landmarkname() {
  _impl_.landmarkname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::landmarkname() const {
  // @@protoc_insertion_point(field_get:CSVCMsg_GameSessionConfiguration.landmarkname)
  return _internal_landmarkname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CSVCMsg_GameSessionConfiguration::set_landmarkname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.landmarkname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CSVCMsg_GameSessionConfiguration.landmarkname)
}
inline std::string* CSVCMsg_GameSessionConfiguration::mutable_landmarkname() {
  std::string* _s = _internal_mutable_landmarkname();
  // @@protoc_insertion_point(field_mutable:CSVCMsg_GameSessionConfiguration.landmarkname)
  return _s;
}
inline const std::string& CSVCMsg_GameSessionConfiguration::_internal_landmarkname() const {
  return _impl_.landmarkname_.Get();
}
inline void CSVCMsg_GameSessionConfiguration::_internal_set_landmarkname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.landmarkname_.Set(value, GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::_internal_mutable_landmarkname() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.landmarkname_.Mutable(GetArenaForAllocation());
}
inline std::string* CSVCMsg_GameSessionConfiguration::release_landmarkname() {
  // @@protoc_insertion_point(field_release:CSVCMsg_GameSessionConfiguration.landmarkname)
  if (!_internal_has_landmarkname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.landmarkname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.landmarkname_.IsDefault()) {
    _impl_.landmarkname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CSVCMsg_GameSessionConfiguration::set_allocated_landmarkname(std::string* landmarkname) {
  if (landmarkname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.landmarkname_.SetAllocated(landmarkname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.landmarkname_.IsDefault()) {
    _impl_.landmarkname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CSVCMsg_GameSessionConfiguration.landmarkname)
}

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

// CNETMsg_DebugOverlay

// optional int32 etype = 1;
inline bool CNETMsg_DebugOverlay::_internal_has_etype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CNETMsg_DebugOverlay::has_etype() const {
  return _internal_has_etype();
}
inline void CNETMsg_DebugOverlay::clear_etype() {
  _impl_.etype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CNETMsg_DebugOverlay::_internal_etype() const {
  return _impl_.etype_;
}
inline int32_t CNETMsg_DebugOverlay::etype() const {
  // @@protoc_insertion_point(field_get:CNETMsg_DebugOverlay.etype)
  return _internal_etype();
}
inline void CNETMsg_DebugOverlay::_internal_set_etype(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.etype_ = value;
}
inline void CNETMsg_DebugOverlay::set_etype(int32_t value) {
  _internal_set_etype(value);
  // @@protoc_insertion_point(field_set:CNETMsg_DebugOverlay.etype)
}

// repeated .CMsgVector vectors = 2;
inline int CNETMsg_DebugOverlay::_internal_vectors_size() const {
  return _impl_.vectors_.size();
}
inline int CNETMsg_DebugOverlay::vectors_size() const {
  return _internal_vectors_size();
}
inline void CNETMsg_DebugOverlay::clear_vectors() {
  _impl_.vectors_.Clear();
}
inline ::CMsgVector* CNETMsg_DebugOverlay::mutable_vectors(int index) {
  // @@protoc_insertion_point(field_mutable:CNETMsg_DebugOverlay.vectors)
  return _impl_.vectors_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgVector >*
CNETMsg_DebugOverlay::mutable_vectors() {
  // @@protoc_insertion_point(field_mutable_list:CNETMsg_DebugOverlay.vectors)
  return &_impl_.vectors_;
}
inline const ::CMsgVector& CNETMsg_DebugOverlay::_internal_vectors(int index) const {
  return _impl_.vectors_.Get(index);
}
inline const ::CMsgVector& CNETMsg_DebugOverlay::vectors(int index) const {
  // @@protoc_insertion_point(field_get:CNETMsg_DebugOverlay.vectors)
  return _internal_vectors(index);
}
inline ::CMsgVector* CNETMsg_DebugOverlay::_internal_add_vectors() {
  return _impl_.vectors_.Add();
}
inline ::CMsgVector* CNETMsg_DebugOverlay::add_vectors() {
  ::CMsgVector* _add = _internal_add_vectors();
  // @@protoc_insertion_point(field_add:CNETMsg_DebugOverlay.vectors)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgVector >&
CNETMsg_DebugOverlay::vectors() const {
  // @@protoc_insertion_point(field_list:CNETMsg_DebugOverlay.vectors)
  return _impl_.vectors_;
}

// repeated .CMsgRGBA colors = 3;
inline int CNETMsg_DebugOverlay::_internal_colors_size() const {
  return _impl_.colors_.size();
}
inline int CNETMsg_DebugOverlay::colors_size() const {
  return _internal_colors_size();
}
inline void CNETMsg_DebugOverlay::clear_colors() {
  _impl_.colors_.Clear();
}
inline ::CMsgRGBA* CNETMsg_DebugOverlay::mutable_colors(int index) {
  // @@protoc_insertion_point(field_mutable:CNETMsg_DebugOverlay.colors)
  return _impl_.colors_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgRGBA >*
CNETMsg_DebugOverlay::mutable_colors() {
  // @@protoc_insertion_point(field_mutable_list:CNETMsg_DebugOverlay.colors)
  return &_impl_.colors_;
}
inline const ::CMsgRGBA& CNETMsg_DebugOverlay::_internal_colors(int index) const {
  return _impl_.colors_.Get(index);
}
inline const ::CMsgRGBA& CNETMsg_DebugOverlay::colors(int index) const {
  // @@protoc_insertion_point(field_get:CNETMsg_DebugOverlay.colors)
  return _internal_colors(index);
}
inline ::CMsgRGBA* CNETMsg_DebugOverlay::_internal_add_colors() {
  return _impl_.colors_.Add();
}
inline ::CMsgRGBA* CNETMsg_DebugOverlay::add_colors() {
  ::CMsgRGBA* _add = _internal_add_colors();
  // @@protoc_insertion_point(field_add:CNETMsg_DebugOverlay.colors)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgRGBA >&
CNETMsg_DebugOverlay::colors() const {
  // @@protoc_insertion_point(field_list:CNETMsg_DebugOverlay.colors)
  return _impl_.colors_;
}

// repeated float dimensions = 4;
inline int CNETMsg_DebugOverlay::_internal_dimensions_size() const {
  return _impl_.dimensions_.size();
}
inline int CNETMsg_DebugOverlay::dimensions_size() const {
  return _internal_dimensions_size();
}
inline void CNETMsg_DebugOverlay::clear_dimensions() {
  _impl_.dimensions_.Clear();
}
inline float CNETMsg_DebugOverlay::_internal_dimensions(int index) const {
  return _impl_.dimensions_.Get(index);
}
inline float CNETMsg_DebugOverlay::dimensions(int index) const {
  // @@protoc_insertion_point(field_get:CNETMsg_DebugOverlay.dimensions)
  return _internal_dimensions(index);
}
inline void CNETMsg_DebugOverlay::set_dimensions(int index, float value) {
  _impl_.dimensions_.Set(index, value);
  // @@protoc_insertion_point(field_set:CNETMsg_DebugOverlay.dimensions)
}
inline void CNETMsg_DebugOverlay::_internal_add_dimensions(float value) {
  _impl_.dimensions_.Add(value);
}
inline void CNETMsg_DebugOverlay::add_dimensions(float value) {
  _internal_add_dimensions(value);
  // @@protoc_insertion_point(field_add:CNETMsg_DebugOverlay.dimensions)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
CNETMsg_DebugOverlay::_internal_dimensions() const {
  return _impl_.dimensions_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
CNETMsg_DebugOverlay::dimensions() const {
  // @@protoc_insertion_point(field_list:CNETMsg_DebugOverlay.dimensions)
  return _internal_dimensions();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
CNETMsg_DebugOverlay::_internal_mutable_dimensions() {
  return &_impl_.dimensions_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
CNETMsg_DebugOverlay::mutable_dimensions() {
  // @@protoc_insertion_point(field_mutable_list:CNETMsg_DebugOverlay.dimensions)
  return _internal_mutable_dimensions();
}

// repeated float times = 5;
inline int CNETMsg_DebugOverlay::_internal_times_size() const {
  return _impl_.times_.size();
}
inline int CNETMsg_DebugOverlay::times_size() const {
  return _internal_times_size();
}
inline void CNETMsg_DebugOverlay::clear_times() {
  _impl_.times_.Clear();
}
inline float CNETMsg_DebugOverlay::_internal_times(int index) const {
  return _impl_.times_.Get(index);
}
inline float CNETMsg_DebugOverlay::times(int index) const {
  // @@protoc_insertion_point(field_get:CNETMsg_DebugOverlay.times)
  return _internal_times(index);
}
inline void CNETMsg_DebugOverlay::set_times(int index, float value) {
  _impl_.times_.Set(index, value);
  // @@protoc_insertion_point(field_set:CNETMsg_DebugOverlay.times)
}
inline void CNETMsg_DebugOverlay::_internal_add_times(float value) {
  _impl_.times_.Add(value);
}
inline void CNETMsg_DebugOverlay::add_times(float value) {
  _internal_add_times(value);
  // @@protoc_insertion_point(field_add:CNETMsg_DebugOverlay.times)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
CNETMsg_DebugOverlay::_internal_times() const {
  return _impl_.times_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
CNETMsg_DebugOverlay::times() const {
  // @@protoc_insertion_point(field_list:CNETMsg_DebugOverlay.times)
  return _internal_times();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
CNETMsg_DebugOverlay::_internal_mutable_times() {
  return &_impl_.times_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
CNETMsg_DebugOverlay::mutable_times() {
  // @@protoc_insertion_point(field_mutable_list:CNETMsg_DebugOverlay.times)
  return _internal_mutable_times();
}

// repeated bool bools = 6;
inline int CNETMsg_DebugOverlay::_internal_bools_size() const {
  return _impl_.bools_.size();
}
inline int CNETMsg_DebugOverlay::bools_size() const {
  return _internal_bools_size();
}
inline void CNETMsg_DebugOverlay::clear_bools() {
  _impl_.bools_.Clear();
}
inline bool CNETMsg_DebugOverlay::_internal_bools(int index) const {
  return _impl_.bools_.Get(index);
}
inline bool CNETMsg_DebugOverlay::bools(int index) const {
  // @@protoc_insertion_point(field_get:CNETMsg_DebugOverlay.bools)
  return _internal_bools(index);
}
inline void CNETMsg_DebugOverlay::set_bools(int index, bool value) {
  _impl_.bools_.Set(index, value);
  // @@protoc_insertion_point(field_set:CNETMsg_DebugOverlay.bools)
}
inline void CNETMsg_DebugOverlay::_internal_add_bools(bool value) {
  _impl_.bools_.Add(value);
}
inline void CNETMsg_DebugOverlay::add_bools(bool value) {
  _internal_add_bools(value);
  // @@protoc_insertion_point(field_add:CNETMsg_DebugOverlay.bools)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
CNETMsg_DebugOverlay::_internal_bools() const {
  return _impl_.bools_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
CNETMsg_DebugOverlay::bools() const {
  // @@protoc_insertion_point(field_list:CNETMsg_DebugOverlay.bools)
  return _internal_bools();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
CNETMsg_DebugOverlay::_internal_mutable_bools() {
  return &_impl_.bools_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
CNETMsg_DebugOverlay::mutable_bools() {
  // @@protoc_insertion_point(field_mutable_list:CNETMsg_DebugOverlay.bools)
  return _internal_mutable_bools();
}

// repeated uint64 uint64s = 7;
inline int CNETMsg_DebugOverlay::_internal_uint64s_size() const {
  return _impl_.uint64s_.size();
}
inline int CNETMsg_DebugOverlay::uint64s_size() const {
  return _internal_uint64s_size();
}
inline void CNETMsg_DebugOverlay::clear_uint64s() {
  _impl_.uint64s_.Clear();
}
inline uint64_t CNETMsg_DebugOverlay::_internal_uint64s(int index) const {
  return _impl_.uint64s_.Get(index);
}
inline uint64_t CNETMsg_DebugOverlay::uint64s(int index) const {
  // @@protoc_insertion_point(field_get:CNETMsg_DebugOverlay.uint64s)
  return _internal_uint64s(index);
}
inline void CNETMsg_DebugOverlay::set_uint64s(int index, uint64_t value) {
  _impl_.uint64s_.Set(index, value);
  // @@protoc_insertion_point(field_set:CNETMsg_DebugOverlay.uint64s)
}
inline void CNETMsg_DebugOverlay::_internal_add_uint64s(uint64_t value) {
  _impl_.uint64s_.Add(value);
}
inline void CNETMsg_DebugOverlay::add_uint64s(uint64_t value) {
  _internal_add_uint64s(value);
  // @@protoc_insertion_point(field_add:CNETMsg_DebugOverlay.uint64s)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
CNETMsg_DebugOverlay::_internal_uint64s() const {
  return _impl_.uint64s_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
CNETMsg_DebugOverlay::uint64s() const {
  // @@protoc_insertion_point(field_list:CNETMsg_DebugOverlay.uint64s)
  return _internal_uint64s();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
CNETMsg_DebugOverlay::_internal_mutable_uint64s() {
  return &_impl_.uint64s_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
CNETMsg_DebugOverlay::mutable_uint64s() {
  // @@protoc_insertion_point(field_mutable_list:CNETMsg_DebugOverlay.uint64s)
  return _internal_mutable_uint64s();
}

// repeated string strings = 8;
inline int CNETMsg_DebugOverlay::_internal_strings_size() const {
  return _impl_.strings_.size();
}
inline int CNETMsg_DebugOverlay::strings_size() const {
  return _internal_strings_size();
}
inline void CNETMsg_DebugOverlay::clear_strings() {
  _impl_.strings_.Clear();
}
inline std::string* CNETMsg_DebugOverlay::add_strings() {
  std::string* _s = _internal_add_strings();
  // @@protoc_insertion_point(field_add_mutable:CNETMsg_DebugOverlay.strings)
  return _s;
}
inline const std::string& CNETMsg_DebugOverlay::_internal_strings(int index) const {
  return _impl_.strings_.Get(index);
}
inline const std::string& CNETMsg_DebugOverlay::strings(int index) const {
  // @@protoc_insertion_point(field_get:CNETMsg_DebugOverlay.strings)
  return _internal_strings(index);
}
inline std::string* CNETMsg_DebugOverlay::mutable_strings(int index) {
  // @@protoc_insertion_point(field_mutable:CNETMsg_DebugOverlay.strings)
  return _impl_.strings_.Mutable(index);
}
inline void CNETMsg_DebugOverlay::set_strings(int index, const std::string& value) {
  _impl_.strings_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:CNETMsg_DebugOverlay.strings)
}
inline void CNETMsg_DebugOverlay::set_strings(int index, std::string&& value) {
  _impl_.strings_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:CNETMsg_DebugOverlay.strings)
}
inline void CNETMsg_DebugOverlay::set_strings(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.strings_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:CNETMsg_DebugOverlay.strings)
}
inline void CNETMsg_DebugOverlay::set_strings(int index, const char* value, size_t size) {
  _impl_.strings_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:CNETMsg_DebugOverlay.strings)
}
inline std::string* CNETMsg_DebugOverlay::_internal_add_strings() {
  return _impl_.strings_.Add();
}
inline void CNETMsg_DebugOverlay::add_strings(const std::string& value) {
  _impl_.strings_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:CNETMsg_DebugOverlay.strings)
}
inline void CNETMsg_DebugOverlay::add_strings(std::string&& value) {
  _impl_.strings_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:CNETMsg_DebugOverlay.strings)
}
inline void CNETMsg_DebugOverlay::add_strings(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.strings_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:CNETMsg_DebugOverlay.strings)
}
inline void CNETMsg_DebugOverlay::add_strings(const char* value, size_t size) {
  _impl_.strings_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:CNETMsg_DebugOverlay.strings)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
CNETMsg_DebugOverlay::strings() const {
  // @@protoc_insertion_point(field_list:CNETMsg_DebugOverlay.strings)
  return _impl_.strings_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
CNETMsg_DebugOverlay::mutable_strings() {
  // @@protoc_insertion_point(field_mutable_list:CNETMsg_DebugOverlay.strings)
  return &_impl_.strings_;
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::SignonState_t> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::SignonState_t>() {
  return ::SignonState_t_descriptor();
}
template <> struct is_proto_enum< ::NET_Messages> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::NET_Messages>() {
  return ::NET_Messages_descriptor();
}
template <> struct is_proto_enum< ::SpawnGroupFlags_t> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::SpawnGroupFlags_t>() {
  return ::SpawnGroupFlags_t_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_networkbasetypes_2eproto
