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

#ifndef GOOGLE_PROTOBUF_INCLUDED_gameevents_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_gameevents_2eproto

#include <limits>
#include <string>

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

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

// Internal implementation detail -- do not use these members.
struct TableStruct_gameevents_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_gameevents_2eproto;
class CMsgClearDecalsForEntityEvent;
struct CMsgClearDecalsForEntityEventDefaultTypeInternal;
extern CMsgClearDecalsForEntityEventDefaultTypeInternal _CMsgClearDecalsForEntityEvent_default_instance_;
class CMsgClearEntityDecalsEvent;
struct CMsgClearEntityDecalsEventDefaultTypeInternal;
extern CMsgClearEntityDecalsEventDefaultTypeInternal _CMsgClearEntityDecalsEvent_default_instance_;
class CMsgClearWorldDecalsEvent;
struct CMsgClearWorldDecalsEventDefaultTypeInternal;
extern CMsgClearWorldDecalsEventDefaultTypeInternal _CMsgClearWorldDecalsEvent_default_instance_;
class CMsgPlaceDecalEvent;
struct CMsgPlaceDecalEventDefaultTypeInternal;
extern CMsgPlaceDecalEventDefaultTypeInternal _CMsgPlaceDecalEvent_default_instance_;
class CMsgSosSetLibraryStackFields;
struct CMsgSosSetLibraryStackFieldsDefaultTypeInternal;
extern CMsgSosSetLibraryStackFieldsDefaultTypeInternal _CMsgSosSetLibraryStackFields_default_instance_;
class CMsgSosSetSoundEventParams;
struct CMsgSosSetSoundEventParamsDefaultTypeInternal;
extern CMsgSosSetSoundEventParamsDefaultTypeInternal _CMsgSosSetSoundEventParams_default_instance_;
class CMsgSosStartSoundEvent;
struct CMsgSosStartSoundEventDefaultTypeInternal;
extern CMsgSosStartSoundEventDefaultTypeInternal _CMsgSosStartSoundEvent_default_instance_;
class CMsgSosStopSoundEvent;
struct CMsgSosStopSoundEventDefaultTypeInternal;
extern CMsgSosStopSoundEventDefaultTypeInternal _CMsgSosStopSoundEvent_default_instance_;
class CMsgSosStopSoundEventHash;
struct CMsgSosStopSoundEventHashDefaultTypeInternal;
extern CMsgSosStopSoundEventHashDefaultTypeInternal _CMsgSosStopSoundEventHash_default_instance_;
class CMsgSource1LegacyGameEvent;
struct CMsgSource1LegacyGameEventDefaultTypeInternal;
extern CMsgSource1LegacyGameEventDefaultTypeInternal _CMsgSource1LegacyGameEvent_default_instance_;
class CMsgSource1LegacyGameEventList;
struct CMsgSource1LegacyGameEventListDefaultTypeInternal;
extern CMsgSource1LegacyGameEventListDefaultTypeInternal _CMsgSource1LegacyGameEventList_default_instance_;
class CMsgSource1LegacyGameEventList_descriptor_t;
struct CMsgSource1LegacyGameEventList_descriptor_tDefaultTypeInternal;
extern CMsgSource1LegacyGameEventList_descriptor_tDefaultTypeInternal _CMsgSource1LegacyGameEventList_descriptor_t_default_instance_;
class CMsgSource1LegacyGameEventList_key_t;
struct CMsgSource1LegacyGameEventList_key_tDefaultTypeInternal;
extern CMsgSource1LegacyGameEventList_key_tDefaultTypeInternal _CMsgSource1LegacyGameEventList_key_t_default_instance_;
class CMsgSource1LegacyGameEvent_key_t;
struct CMsgSource1LegacyGameEvent_key_tDefaultTypeInternal;
extern CMsgSource1LegacyGameEvent_key_tDefaultTypeInternal _CMsgSource1LegacyGameEvent_key_t_default_instance_;
class CMsgSource1LegacyListenEvents;
struct CMsgSource1LegacyListenEventsDefaultTypeInternal;
extern CMsgSource1LegacyListenEventsDefaultTypeInternal _CMsgSource1LegacyListenEvents_default_instance_;
class CMsgVDebugGameSessionIDEvent;
struct CMsgVDebugGameSessionIDEventDefaultTypeInternal;
extern CMsgVDebugGameSessionIDEventDefaultTypeInternal _CMsgVDebugGameSessionIDEvent_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::CMsgClearDecalsForEntityEvent* Arena::CreateMaybeMessage<::CMsgClearDecalsForEntityEvent>(Arena*);
template<> ::CMsgClearEntityDecalsEvent* Arena::CreateMaybeMessage<::CMsgClearEntityDecalsEvent>(Arena*);
template<> ::CMsgClearWorldDecalsEvent* Arena::CreateMaybeMessage<::CMsgClearWorldDecalsEvent>(Arena*);
template<> ::CMsgPlaceDecalEvent* Arena::CreateMaybeMessage<::CMsgPlaceDecalEvent>(Arena*);
template<> ::CMsgSosSetLibraryStackFields* Arena::CreateMaybeMessage<::CMsgSosSetLibraryStackFields>(Arena*);
template<> ::CMsgSosSetSoundEventParams* Arena::CreateMaybeMessage<::CMsgSosSetSoundEventParams>(Arena*);
template<> ::CMsgSosStartSoundEvent* Arena::CreateMaybeMessage<::CMsgSosStartSoundEvent>(Arena*);
template<> ::CMsgSosStopSoundEvent* Arena::CreateMaybeMessage<::CMsgSosStopSoundEvent>(Arena*);
template<> ::CMsgSosStopSoundEventHash* Arena::CreateMaybeMessage<::CMsgSosStopSoundEventHash>(Arena*);
template<> ::CMsgSource1LegacyGameEvent* Arena::CreateMaybeMessage<::CMsgSource1LegacyGameEvent>(Arena*);
template<> ::CMsgSource1LegacyGameEventList* Arena::CreateMaybeMessage<::CMsgSource1LegacyGameEventList>(Arena*);
template<> ::CMsgSource1LegacyGameEventList_descriptor_t* Arena::CreateMaybeMessage<::CMsgSource1LegacyGameEventList_descriptor_t>(Arena*);
template<> ::CMsgSource1LegacyGameEventList_key_t* Arena::CreateMaybeMessage<::CMsgSource1LegacyGameEventList_key_t>(Arena*);
template<> ::CMsgSource1LegacyGameEvent_key_t* Arena::CreateMaybeMessage<::CMsgSource1LegacyGameEvent_key_t>(Arena*);
template<> ::CMsgSource1LegacyListenEvents* Arena::CreateMaybeMessage<::CMsgSource1LegacyListenEvents>(Arena*);
template<> ::CMsgVDebugGameSessionIDEvent* Arena::CreateMaybeMessage<::CMsgVDebugGameSessionIDEvent>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum EBaseGameEvents : int {
  GE_VDebugGameSessionIDEvent = 200,
  GE_PlaceDecalEvent = 201,
  GE_ClearWorldDecalsEvent = 202,
  GE_ClearEntityDecalsEvent = 203,
  GE_ClearDecalsForEntityEvent = 204,
  GE_Source1LegacyGameEventList = 205,
  GE_Source1LegacyListenEvents = 206,
  GE_Source1LegacyGameEvent = 207,
  GE_SosStartSoundEvent = 208,
  GE_SosStopSoundEvent = 209,
  GE_SosSetSoundEventParams = 210,
  GE_SosSetLibraryStackFields = 211,
  GE_SosStopSoundEventHash = 212
};
bool EBaseGameEvents_IsValid(int value);
constexpr EBaseGameEvents EBaseGameEvents_MIN = GE_VDebugGameSessionIDEvent;
constexpr EBaseGameEvents EBaseGameEvents_MAX = GE_SosStopSoundEventHash;
constexpr int EBaseGameEvents_ARRAYSIZE = EBaseGameEvents_MAX + 1;

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

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

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

  inline CMsgVDebugGameSessionIDEvent& operator=(const CMsgVDebugGameSessionIDEvent& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgVDebugGameSessionIDEvent& operator=(CMsgVDebugGameSessionIDEvent&& 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 CMsgVDebugGameSessionIDEvent& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgVDebugGameSessionIDEvent* internal_default_instance() {
    return reinterpret_cast<const CMsgVDebugGameSessionIDEvent*>(
               &_CMsgVDebugGameSessionIDEvent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(CMsgVDebugGameSessionIDEvent& a, CMsgVDebugGameSessionIDEvent& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgVDebugGameSessionIDEvent* 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(CMsgVDebugGameSessionIDEvent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgVDebugGameSessionIDEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgVDebugGameSessionIDEvent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgVDebugGameSessionIDEvent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgVDebugGameSessionIDEvent& from) {
    CMsgVDebugGameSessionIDEvent::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(CMsgVDebugGameSessionIDEvent* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgVDebugGameSessionIDEvent";
  }
  protected:
  explicit CMsgVDebugGameSessionIDEvent(::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 {
    kGamesessionidFieldNumber = 2,
    kClientidFieldNumber = 1,
  };
  // optional string gamesessionid = 2;
  bool has_gamesessionid() const;
  private:
  bool _internal_has_gamesessionid() const;
  public:
  void clear_gamesessionid();
  const std::string& gamesessionid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_gamesessionid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_gamesessionid();
  PROTOBUF_NODISCARD std::string* release_gamesessionid();
  void set_allocated_gamesessionid(std::string* gamesessionid);
  private:
  const std::string& _internal_gamesessionid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_gamesessionid(const std::string& value);
  std::string* _internal_mutable_gamesessionid();
  public:

  // optional int32 clientid = 1;
  bool has_clientid() const;
  private:
  bool _internal_has_clientid() const;
  public:
  void clear_clientid();
  int32_t clientid() const;
  void set_clientid(int32_t value);
  private:
  int32_t _internal_clientid() const;
  void _internal_set_clientid(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgVDebugGameSessionIDEvent)
 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 gamesessionid_;
    int32_t clientid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gameevents_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgPlaceDecalEvent& operator=(const CMsgPlaceDecalEvent& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgPlaceDecalEvent& operator=(CMsgPlaceDecalEvent&& 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 CMsgPlaceDecalEvent& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgPlaceDecalEvent* internal_default_instance() {
    return reinterpret_cast<const CMsgPlaceDecalEvent*>(
               &_CMsgPlaceDecalEvent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(CMsgPlaceDecalEvent& a, CMsgPlaceDecalEvent& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgPlaceDecalEvent* 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(CMsgPlaceDecalEvent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgPlaceDecalEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgPlaceDecalEvent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgPlaceDecalEvent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgPlaceDecalEvent& from) {
    CMsgPlaceDecalEvent::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(CMsgPlaceDecalEvent* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgPlaceDecalEvent";
  }
  protected:
  explicit CMsgPlaceDecalEvent(::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,
    kNormalFieldNumber = 2,
    kSaxisFieldNumber = 3,
    kBoneindexFieldNumber = 4,
    kFlagsFieldNumber = 5,
    kColorFieldNumber = 6,
    kRandomSeedFieldNumber = 7,
    kDecalGroupNameFieldNumber = 8,
    kSizeOverrideFieldNumber = 9,
    kMaterialIdFieldNumber = 11,
    kSequenceNameFieldNumber = 12,
    kTriangleindexFieldNumber = 13,
    kEntityhandleFieldNumber = 10,
  };
  // 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 .CMsgVector normal = 2;
  bool has_normal() const;
  private:
  bool _internal_has_normal() const;
  public:
  void clear_normal();
  const ::CMsgVector& normal() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_normal();
  ::CMsgVector* mutable_normal();
  void set_allocated_normal(::CMsgVector* normal);
  private:
  const ::CMsgVector& _internal_normal() const;
  ::CMsgVector* _internal_mutable_normal();
  public:
  void unsafe_arena_set_allocated_normal(
      ::CMsgVector* normal);
  ::CMsgVector* unsafe_arena_release_normal();

  // optional .CMsgVector saxis = 3;
  bool has_saxis() const;
  private:
  bool _internal_has_saxis() const;
  public:
  void clear_saxis();
  const ::CMsgVector& saxis() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_saxis();
  ::CMsgVector* mutable_saxis();
  void set_allocated_saxis(::CMsgVector* saxis);
  private:
  const ::CMsgVector& _internal_saxis() const;
  ::CMsgVector* _internal_mutable_saxis();
  public:
  void unsafe_arena_set_allocated_saxis(
      ::CMsgVector* saxis);
  ::CMsgVector* unsafe_arena_release_saxis();

  // optional int32 boneindex = 4;
  bool has_boneindex() const;
  private:
  bool _internal_has_boneindex() const;
  public:
  void clear_boneindex();
  int32_t boneindex() const;
  void set_boneindex(int32_t value);
  private:
  int32_t _internal_boneindex() const;
  void _internal_set_boneindex(int32_t value);
  public:

  // optional uint32 flags = 5;
  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 fixed32 color = 6;
  bool has_color() const;
  private:
  bool _internal_has_color() const;
  public:
  void clear_color();
  uint32_t color() const;
  void set_color(uint32_t value);
  private:
  uint32_t _internal_color() const;
  void _internal_set_color(uint32_t value);
  public:

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

  // optional uint32 decal_group_name = 8;
  bool has_decal_group_name() const;
  private:
  bool _internal_has_decal_group_name() const;
  public:
  void clear_decal_group_name();
  uint32_t decal_group_name() const;
  void set_decal_group_name(uint32_t value);
  private:
  uint32_t _internal_decal_group_name() const;
  void _internal_set_decal_group_name(uint32_t value);
  public:

  // optional float size_override = 9;
  bool has_size_override() const;
  private:
  bool _internal_has_size_override() const;
  public:
  void clear_size_override();
  float size_override() const;
  void set_size_override(float value);
  private:
  float _internal_size_override() const;
  void _internal_set_size_override(float value);
  public:

  // optional uint64 material_id = 11;
  bool has_material_id() const;
  private:
  bool _internal_has_material_id() const;
  public:
  void clear_material_id();
  uint64_t material_id() const;
  void set_material_id(uint64_t value);
  private:
  uint64_t _internal_material_id() const;
  void _internal_set_material_id(uint64_t value);
  public:

  // optional uint32 sequence_name = 12;
  bool has_sequence_name() const;
  private:
  bool _internal_has_sequence_name() const;
  public:
  void clear_sequence_name();
  uint32_t sequence_name() const;
  void set_sequence_name(uint32_t value);
  private:
  uint32_t _internal_sequence_name() const;
  void _internal_set_sequence_name(uint32_t value);
  public:

  // optional int32 triangleindex = 13;
  bool has_triangleindex() const;
  private:
  bool _internal_has_triangleindex() const;
  public:
  void clear_triangleindex();
  int32_t triangleindex() const;
  void set_triangleindex(int32_t value);
  private:
  int32_t _internal_triangleindex() const;
  void _internal_set_triangleindex(int32_t value);
  public:

  // optional uint32 entityhandle = 10 [default = 16777215];
  bool has_entityhandle() const;
  private:
  bool _internal_has_entityhandle() const;
  public:
  void clear_entityhandle();
  uint32_t entityhandle() const;
  void set_entityhandle(uint32_t value);
  private:
  uint32_t _internal_entityhandle() const;
  void _internal_set_entityhandle(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgPlaceDecalEvent)
 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_;
    ::CMsgVector* normal_;
    ::CMsgVector* saxis_;
    int32_t boneindex_;
    uint32_t flags_;
    uint32_t color_;
    int32_t random_seed_;
    uint32_t decal_group_name_;
    float size_override_;
    uint64_t material_id_;
    uint32_t sequence_name_;
    int32_t triangleindex_;
    uint32_t entityhandle_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gameevents_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgClearWorldDecalsEvent& operator=(const CMsgClearWorldDecalsEvent& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgClearWorldDecalsEvent& operator=(CMsgClearWorldDecalsEvent&& 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 CMsgClearWorldDecalsEvent& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgClearWorldDecalsEvent* internal_default_instance() {
    return reinterpret_cast<const CMsgClearWorldDecalsEvent*>(
               &_CMsgClearWorldDecalsEvent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(CMsgClearWorldDecalsEvent& a, CMsgClearWorldDecalsEvent& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgClearWorldDecalsEvent* 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(CMsgClearWorldDecalsEvent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgClearWorldDecalsEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgClearWorldDecalsEvent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgClearWorldDecalsEvent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgClearWorldDecalsEvent& from) {
    CMsgClearWorldDecalsEvent::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(CMsgClearWorldDecalsEvent* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgClearWorldDecalsEvent";
  }
  protected:
  explicit CMsgClearWorldDecalsEvent(::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 {
    kFlagstoclearFieldNumber = 1,
  };
  // optional uint32 flagstoclear = 1;
  bool has_flagstoclear() const;
  private:
  bool _internal_has_flagstoclear() const;
  public:
  void clear_flagstoclear();
  uint32_t flagstoclear() const;
  void set_flagstoclear(uint32_t value);
  private:
  uint32_t _internal_flagstoclear() const;
  void _internal_set_flagstoclear(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgClearWorldDecalsEvent)
 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 flagstoclear_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gameevents_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgClearEntityDecalsEvent& operator=(const CMsgClearEntityDecalsEvent& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgClearEntityDecalsEvent& operator=(CMsgClearEntityDecalsEvent&& 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 CMsgClearEntityDecalsEvent& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgClearEntityDecalsEvent* internal_default_instance() {
    return reinterpret_cast<const CMsgClearEntityDecalsEvent*>(
               &_CMsgClearEntityDecalsEvent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(CMsgClearEntityDecalsEvent& a, CMsgClearEntityDecalsEvent& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgClearEntityDecalsEvent* 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(CMsgClearEntityDecalsEvent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgClearEntityDecalsEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgClearEntityDecalsEvent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgClearEntityDecalsEvent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgClearEntityDecalsEvent& from) {
    CMsgClearEntityDecalsEvent::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(CMsgClearEntityDecalsEvent* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgClearEntityDecalsEvent";
  }
  protected:
  explicit CMsgClearEntityDecalsEvent(::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 {
    kFlagstoclearFieldNumber = 1,
  };
  // optional uint32 flagstoclear = 1;
  bool has_flagstoclear() const;
  private:
  bool _internal_has_flagstoclear() const;
  public:
  void clear_flagstoclear();
  uint32_t flagstoclear() const;
  void set_flagstoclear(uint32_t value);
  private:
  uint32_t _internal_flagstoclear() const;
  void _internal_set_flagstoclear(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgClearEntityDecalsEvent)
 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 flagstoclear_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gameevents_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgClearDecalsForEntityEvent& operator=(const CMsgClearDecalsForEntityEvent& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgClearDecalsForEntityEvent& operator=(CMsgClearDecalsForEntityEvent&& 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 CMsgClearDecalsForEntityEvent& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgClearDecalsForEntityEvent* internal_default_instance() {
    return reinterpret_cast<const CMsgClearDecalsForEntityEvent*>(
               &_CMsgClearDecalsForEntityEvent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(CMsgClearDecalsForEntityEvent& a, CMsgClearDecalsForEntityEvent& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgClearDecalsForEntityEvent* 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(CMsgClearDecalsForEntityEvent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgClearDecalsForEntityEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgClearDecalsForEntityEvent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgClearDecalsForEntityEvent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgClearDecalsForEntityEvent& from) {
    CMsgClearDecalsForEntityEvent::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(CMsgClearDecalsForEntityEvent* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgClearDecalsForEntityEvent";
  }
  protected:
  explicit CMsgClearDecalsForEntityEvent(::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 {
    kFlagstoclearFieldNumber = 1,
    kEntityhandleFieldNumber = 2,
  };
  // optional uint32 flagstoclear = 1;
  bool has_flagstoclear() const;
  private:
  bool _internal_has_flagstoclear() const;
  public:
  void clear_flagstoclear();
  uint32_t flagstoclear() const;
  void set_flagstoclear(uint32_t value);
  private:
  uint32_t _internal_flagstoclear() const;
  void _internal_set_flagstoclear(uint32_t value);
  public:

  // optional uint32 entityhandle = 2 [default = 16777215];
  bool has_entityhandle() const;
  private:
  bool _internal_has_entityhandle() const;
  public:
  void clear_entityhandle();
  uint32_t entityhandle() const;
  void set_entityhandle(uint32_t value);
  private:
  uint32_t _internal_entityhandle() const;
  void _internal_set_entityhandle(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgClearDecalsForEntityEvent)
 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 flagstoclear_;
    uint32_t entityhandle_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gameevents_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSource1LegacyGameEventList_key_t& operator=(const CMsgSource1LegacyGameEventList_key_t& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSource1LegacyGameEventList_key_t& operator=(CMsgSource1LegacyGameEventList_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 CMsgSource1LegacyGameEventList_key_t& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSource1LegacyGameEventList_key_t* internal_default_instance() {
    return reinterpret_cast<const CMsgSource1LegacyGameEventList_key_t*>(
               &_CMsgSource1LegacyGameEventList_key_t_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(CMsgSource1LegacyGameEventList_key_t& a, CMsgSource1LegacyGameEventList_key_t& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSource1LegacyGameEventList_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(CMsgSource1LegacyGameEventList_key_t* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSource1LegacyGameEventList_key_t* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSource1LegacyGameEventList_key_t>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSource1LegacyGameEventList_key_t& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSource1LegacyGameEventList_key_t& from) {
    CMsgSource1LegacyGameEventList_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(CMsgSource1LegacyGameEventList_key_t* other);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  inline CMsgSource1LegacyGameEventList& operator=(const CMsgSource1LegacyGameEventList& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSource1LegacyGameEventList& operator=(CMsgSource1LegacyGameEventList&& 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 CMsgSource1LegacyGameEventList& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSource1LegacyGameEventList* internal_default_instance() {
    return reinterpret_cast<const CMsgSource1LegacyGameEventList*>(
               &_CMsgSource1LegacyGameEventList_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(CMsgSource1LegacyGameEventList& a, CMsgSource1LegacyGameEventList& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSource1LegacyGameEventList* 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(CMsgSource1LegacyGameEventList* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSource1LegacyGameEventList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSource1LegacyGameEventList>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSource1LegacyGameEventList& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSource1LegacyGameEventList& from) {
    CMsgSource1LegacyGameEventList::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(CMsgSource1LegacyGameEventList* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSource1LegacyGameEventList";
  }
  protected:
  explicit CMsgSource1LegacyGameEventList(::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 CMsgSource1LegacyGameEventList_key_t key_t;
  typedef CMsgSource1LegacyGameEventList_descriptor_t descriptor_t;

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

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

  // @@protoc_insertion_point(class_scope:CMsgSource1LegacyGameEventList)
 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< ::CMsgSource1LegacyGameEventList_descriptor_t > descriptors_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gameevents_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSource1LegacyListenEvents& operator=(const CMsgSource1LegacyListenEvents& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSource1LegacyListenEvents& operator=(CMsgSource1LegacyListenEvents&& 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 CMsgSource1LegacyListenEvents& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSource1LegacyListenEvents* internal_default_instance() {
    return reinterpret_cast<const CMsgSource1LegacyListenEvents*>(
               &_CMsgSource1LegacyListenEvents_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(CMsgSource1LegacyListenEvents& a, CMsgSource1LegacyListenEvents& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSource1LegacyListenEvents* 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(CMsgSource1LegacyListenEvents* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSource1LegacyListenEvents* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSource1LegacyListenEvents>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSource1LegacyListenEvents& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSource1LegacyListenEvents& from) {
    CMsgSource1LegacyListenEvents::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(CMsgSource1LegacyListenEvents* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSource1LegacyListenEvents";
  }
  protected:
  explicit CMsgSource1LegacyListenEvents(::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 {
    kEventarraybitsFieldNumber = 2,
    kPlayerslotFieldNumber = 1,
  };
  // repeated uint32 eventarraybits = 2;
  int eventarraybits_size() const;
  private:
  int _internal_eventarraybits_size() const;
  public:
  void clear_eventarraybits();
  private:
  uint32_t _internal_eventarraybits(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_eventarraybits() const;
  void _internal_add_eventarraybits(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_eventarraybits();
  public:
  uint32_t eventarraybits(int index) const;
  void set_eventarraybits(int index, uint32_t value);
  void add_eventarraybits(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      eventarraybits() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_eventarraybits();

  // optional int32 playerslot = 1;
  bool has_playerslot() const;
  private:
  bool _internal_has_playerslot() const;
  public:
  void clear_playerslot();
  int32_t playerslot() const;
  void set_playerslot(int32_t value);
  private:
  int32_t _internal_playerslot() const;
  void _internal_set_playerslot(int32_t value);
  public:

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

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

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

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

  inline CMsgSource1LegacyGameEvent_key_t& operator=(const CMsgSource1LegacyGameEvent_key_t& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSource1LegacyGameEvent_key_t& operator=(CMsgSource1LegacyGameEvent_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 CMsgSource1LegacyGameEvent_key_t& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSource1LegacyGameEvent_key_t* internal_default_instance() {
    return reinterpret_cast<const CMsgSource1LegacyGameEvent_key_t*>(
               &_CMsgSource1LegacyGameEvent_key_t_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(CMsgSource1LegacyGameEvent_key_t& a, CMsgSource1LegacyGameEvent_key_t& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSource1LegacyGameEvent_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(CMsgSource1LegacyGameEvent_key_t* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSource1LegacyGameEvent_key_t* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSource1LegacyGameEvent_key_t>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSource1LegacyGameEvent_key_t& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSource1LegacyGameEvent_key_t& from) {
    CMsgSource1LegacyGameEvent_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(CMsgSource1LegacyGameEvent_key_t* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSource1LegacyGameEvent.key_t";
  }
  protected:
  explicit CMsgSource1LegacyGameEvent_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:CMsgSource1LegacyGameEvent.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_gameevents_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSource1LegacyGameEvent& operator=(const CMsgSource1LegacyGameEvent& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSource1LegacyGameEvent& operator=(CMsgSource1LegacyGameEvent&& 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 CMsgSource1LegacyGameEvent& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSource1LegacyGameEvent* internal_default_instance() {
    return reinterpret_cast<const CMsgSource1LegacyGameEvent*>(
               &_CMsgSource1LegacyGameEvent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(CMsgSource1LegacyGameEvent& a, CMsgSource1LegacyGameEvent& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSource1LegacyGameEvent* 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(CMsgSource1LegacyGameEvent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSource1LegacyGameEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSource1LegacyGameEvent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSource1LegacyGameEvent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSource1LegacyGameEvent& from) {
    CMsgSource1LegacyGameEvent::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(CMsgSource1LegacyGameEvent* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSource1LegacyGameEvent";
  }
  protected:
  explicit CMsgSource1LegacyGameEvent(::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 CMsgSource1LegacyGameEvent_key_t key_t;

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

  enum : int {
    kKeysFieldNumber = 3,
    kEventNameFieldNumber = 1,
    kEventidFieldNumber = 2,
    kServerTickFieldNumber = 4,
    kPassthroughFieldNumber = 5,
  };
  // repeated .CMsgSource1LegacyGameEvent.key_t keys = 3;
  int keys_size() const;
  private:
  int _internal_keys_size() const;
  public:
  void clear_keys();
  ::CMsgSource1LegacyGameEvent_key_t* mutable_keys(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSource1LegacyGameEvent_key_t >*
      mutable_keys();
  private:
  const ::CMsgSource1LegacyGameEvent_key_t& _internal_keys(int index) const;
  ::CMsgSource1LegacyGameEvent_key_t* _internal_add_keys();
  public:
  const ::CMsgSource1LegacyGameEvent_key_t& keys(int index) const;
  ::CMsgSource1LegacyGameEvent_key_t* add_keys();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSource1LegacyGameEvent_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:

  // optional int32 server_tick = 4;
  bool has_server_tick() const;
  private:
  bool _internal_has_server_tick() const;
  public:
  void clear_server_tick();
  int32_t server_tick() const;
  void set_server_tick(int32_t value);
  private:
  int32_t _internal_server_tick() const;
  void _internal_set_server_tick(int32_t value);
  public:

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

  // @@protoc_insertion_point(class_scope:CMsgSource1LegacyGameEvent)
 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< ::CMsgSource1LegacyGameEvent_key_t > keys_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr event_name_;
    int32_t eventid_;
    int32_t server_tick_;
    int32_t passthrough_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gameevents_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSosStartSoundEvent& operator=(const CMsgSosStartSoundEvent& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSosStartSoundEvent& operator=(CMsgSosStartSoundEvent&& 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 CMsgSosStartSoundEvent& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSosStartSoundEvent* internal_default_instance() {
    return reinterpret_cast<const CMsgSosStartSoundEvent*>(
               &_CMsgSosStartSoundEvent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(CMsgSosStartSoundEvent& a, CMsgSosStartSoundEvent& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSosStartSoundEvent* 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(CMsgSosStartSoundEvent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSosStartSoundEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSosStartSoundEvent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSosStartSoundEvent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSosStartSoundEvent& from) {
    CMsgSosStartSoundEvent::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(CMsgSosStartSoundEvent* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSosStartSoundEvent";
  }
  protected:
  explicit CMsgSosStartSoundEvent(::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 {
    kPackedParamsFieldNumber = 5,
    kSoundeventGuidFieldNumber = 1,
    kSoundeventHashFieldNumber = 2,
    kSeedFieldNumber = 4,
    kStartTimeFieldNumber = 6,
    kSourceEntityIndexFieldNumber = 3,
  };
  // optional bytes packed_params = 5;
  bool has_packed_params() const;
  private:
  bool _internal_has_packed_params() const;
  public:
  void clear_packed_params();
  const std::string& packed_params() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_packed_params(ArgT0&& arg0, ArgT... args);
  std::string* mutable_packed_params();
  PROTOBUF_NODISCARD std::string* release_packed_params();
  void set_allocated_packed_params(std::string* packed_params);
  private:
  const std::string& _internal_packed_params() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_packed_params(const std::string& value);
  std::string* _internal_mutable_packed_params();
  public:

  // optional int32 soundevent_guid = 1;
  bool has_soundevent_guid() const;
  private:
  bool _internal_has_soundevent_guid() const;
  public:
  void clear_soundevent_guid();
  int32_t soundevent_guid() const;
  void set_soundevent_guid(int32_t value);
  private:
  int32_t _internal_soundevent_guid() const;
  void _internal_set_soundevent_guid(int32_t value);
  public:

  // optional fixed32 soundevent_hash = 2;
  bool has_soundevent_hash() const;
  private:
  bool _internal_has_soundevent_hash() const;
  public:
  void clear_soundevent_hash();
  uint32_t soundevent_hash() const;
  void set_soundevent_hash(uint32_t value);
  private:
  uint32_t _internal_soundevent_hash() const;
  void _internal_set_soundevent_hash(uint32_t value);
  public:

  // optional int32 seed = 4;
  bool has_seed() const;
  private:
  bool _internal_has_seed() const;
  public:
  void clear_seed();
  int32_t seed() const;
  void set_seed(int32_t value);
  private:
  int32_t _internal_seed() const;
  void _internal_set_seed(int32_t value);
  public:

  // optional float start_time = 6;
  bool has_start_time() const;
  private:
  bool _internal_has_start_time() const;
  public:
  void clear_start_time();
  float start_time() const;
  void set_start_time(float value);
  private:
  float _internal_start_time() const;
  void _internal_set_start_time(float value);
  public:

  // optional int32 source_entity_index = 3 [default = -1];
  bool has_source_entity_index() const;
  private:
  bool _internal_has_source_entity_index() const;
  public:
  void clear_source_entity_index();
  int32_t source_entity_index() const;
  void set_source_entity_index(int32_t value);
  private:
  int32_t _internal_source_entity_index() const;
  void _internal_set_source_entity_index(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSosStartSoundEvent)
 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 packed_params_;
    int32_t soundevent_guid_;
    uint32_t soundevent_hash_;
    int32_t seed_;
    float start_time_;
    int32_t source_entity_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gameevents_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSosStopSoundEvent& operator=(const CMsgSosStopSoundEvent& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSosStopSoundEvent& operator=(CMsgSosStopSoundEvent&& 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 CMsgSosStopSoundEvent& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSosStopSoundEvent* internal_default_instance() {
    return reinterpret_cast<const CMsgSosStopSoundEvent*>(
               &_CMsgSosStopSoundEvent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(CMsgSosStopSoundEvent& a, CMsgSosStopSoundEvent& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSosStopSoundEvent* 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(CMsgSosStopSoundEvent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSosStopSoundEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSosStopSoundEvent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSosStopSoundEvent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSosStopSoundEvent& from) {
    CMsgSosStopSoundEvent::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(CMsgSosStopSoundEvent* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSosStopSoundEvent";
  }
  protected:
  explicit CMsgSosStopSoundEvent(::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 {
    kSoundeventGuidFieldNumber = 1,
  };
  // optional int32 soundevent_guid = 1;
  bool has_soundevent_guid() const;
  private:
  bool _internal_has_soundevent_guid() const;
  public:
  void clear_soundevent_guid();
  int32_t soundevent_guid() const;
  void set_soundevent_guid(int32_t value);
  private:
  int32_t _internal_soundevent_guid() const;
  void _internal_set_soundevent_guid(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSosStopSoundEvent)
 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 soundevent_guid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gameevents_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSosStopSoundEventHash& operator=(const CMsgSosStopSoundEventHash& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSosStopSoundEventHash& operator=(CMsgSosStopSoundEventHash&& 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 CMsgSosStopSoundEventHash& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSosStopSoundEventHash* internal_default_instance() {
    return reinterpret_cast<const CMsgSosStopSoundEventHash*>(
               &_CMsgSosStopSoundEventHash_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(CMsgSosStopSoundEventHash& a, CMsgSosStopSoundEventHash& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSosStopSoundEventHash* 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(CMsgSosStopSoundEventHash* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSosStopSoundEventHash* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSosStopSoundEventHash>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSosStopSoundEventHash& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSosStopSoundEventHash& from) {
    CMsgSosStopSoundEventHash::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(CMsgSosStopSoundEventHash* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSosStopSoundEventHash";
  }
  protected:
  explicit CMsgSosStopSoundEventHash(::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 {
    kSoundeventHashFieldNumber = 1,
    kSourceEntityIndexFieldNumber = 2,
  };
  // optional fixed32 soundevent_hash = 1;
  bool has_soundevent_hash() const;
  private:
  bool _internal_has_soundevent_hash() const;
  public:
  void clear_soundevent_hash();
  uint32_t soundevent_hash() const;
  void set_soundevent_hash(uint32_t value);
  private:
  uint32_t _internal_soundevent_hash() const;
  void _internal_set_soundevent_hash(uint32_t value);
  public:

  // optional int32 source_entity_index = 2 [default = -1];
  bool has_source_entity_index() const;
  private:
  bool _internal_has_source_entity_index() const;
  public:
  void clear_source_entity_index();
  int32_t source_entity_index() const;
  void set_source_entity_index(int32_t value);
  private:
  int32_t _internal_source_entity_index() const;
  void _internal_set_source_entity_index(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSosStopSoundEventHash)
 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 soundevent_hash_;
    int32_t source_entity_index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gameevents_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSosSetSoundEventParams& operator=(const CMsgSosSetSoundEventParams& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSosSetSoundEventParams& operator=(CMsgSosSetSoundEventParams&& 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 CMsgSosSetSoundEventParams& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSosSetSoundEventParams* internal_default_instance() {
    return reinterpret_cast<const CMsgSosSetSoundEventParams*>(
               &_CMsgSosSetSoundEventParams_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(CMsgSosSetSoundEventParams& a, CMsgSosSetSoundEventParams& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSosSetSoundEventParams* 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(CMsgSosSetSoundEventParams* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSosSetSoundEventParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSosSetSoundEventParams>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSosSetSoundEventParams& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSosSetSoundEventParams& from) {
    CMsgSosSetSoundEventParams::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(CMsgSosSetSoundEventParams* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSosSetSoundEventParams";
  }
  protected:
  explicit CMsgSosSetSoundEventParams(::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 {
    kPackedParamsFieldNumber = 5,
    kSoundeventGuidFieldNumber = 1,
  };
  // optional bytes packed_params = 5;
  bool has_packed_params() const;
  private:
  bool _internal_has_packed_params() const;
  public:
  void clear_packed_params();
  const std::string& packed_params() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_packed_params(ArgT0&& arg0, ArgT... args);
  std::string* mutable_packed_params();
  PROTOBUF_NODISCARD std::string* release_packed_params();
  void set_allocated_packed_params(std::string* packed_params);
  private:
  const std::string& _internal_packed_params() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_packed_params(const std::string& value);
  std::string* _internal_mutable_packed_params();
  public:

  // optional int32 soundevent_guid = 1;
  bool has_soundevent_guid() const;
  private:
  bool _internal_has_soundevent_guid() const;
  public:
  void clear_soundevent_guid();
  int32_t soundevent_guid() const;
  void set_soundevent_guid(int32_t value);
  private:
  int32_t _internal_soundevent_guid() const;
  void _internal_set_soundevent_guid(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSosSetSoundEventParams)
 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 packed_params_;
    int32_t soundevent_guid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gameevents_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSosSetLibraryStackFields& operator=(const CMsgSosSetLibraryStackFields& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSosSetLibraryStackFields& operator=(CMsgSosSetLibraryStackFields&& 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 CMsgSosSetLibraryStackFields& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSosSetLibraryStackFields* internal_default_instance() {
    return reinterpret_cast<const CMsgSosSetLibraryStackFields*>(
               &_CMsgSosSetLibraryStackFields_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(CMsgSosSetLibraryStackFields& a, CMsgSosSetLibraryStackFields& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSosSetLibraryStackFields* 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(CMsgSosSetLibraryStackFields* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSosSetLibraryStackFields* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSosSetLibraryStackFields>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSosSetLibraryStackFields& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSosSetLibraryStackFields& from) {
    CMsgSosSetLibraryStackFields::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(CMsgSosSetLibraryStackFields* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSosSetLibraryStackFields";
  }
  protected:
  explicit CMsgSosSetLibraryStackFields(::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 {
    kPackedFieldsFieldNumber = 5,
    kStackHashFieldNumber = 1,
  };
  // optional bytes packed_fields = 5;
  bool has_packed_fields() const;
  private:
  bool _internal_has_packed_fields() const;
  public:
  void clear_packed_fields();
  const std::string& packed_fields() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_packed_fields(ArgT0&& arg0, ArgT... args);
  std::string* mutable_packed_fields();
  PROTOBUF_NODISCARD std::string* release_packed_fields();
  void set_allocated_packed_fields(std::string* packed_fields);
  private:
  const std::string& _internal_packed_fields() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_packed_fields(const std::string& value);
  std::string* _internal_mutable_packed_fields();
  public:

  // optional fixed32 stack_hash = 1;
  bool has_stack_hash() const;
  private:
  bool _internal_has_stack_hash() const;
  public:
  void clear_stack_hash();
  uint32_t stack_hash() const;
  void set_stack_hash(uint32_t value);
  private:
  uint32_t _internal_stack_hash() const;
  void _internal_set_stack_hash(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSosSetLibraryStackFields)
 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 packed_fields_;
    uint32_t stack_hash_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_gameevents_2eproto;
};
// ===================================================================


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

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

// optional int32 clientid = 1;
inline bool CMsgVDebugGameSessionIDEvent::_internal_has_clientid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgVDebugGameSessionIDEvent::has_clientid() const {
  return _internal_has_clientid();
}
inline void CMsgVDebugGameSessionIDEvent::clear_clientid() {
  _impl_.clientid_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CMsgVDebugGameSessionIDEvent::_internal_clientid() const {
  return _impl_.clientid_;
}
inline int32_t CMsgVDebugGameSessionIDEvent::clientid() const {
  // @@protoc_insertion_point(field_get:CMsgVDebugGameSessionIDEvent.clientid)
  return _internal_clientid();
}
inline void CMsgVDebugGameSessionIDEvent::_internal_set_clientid(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.clientid_ = value;
}
inline void CMsgVDebugGameSessionIDEvent::set_clientid(int32_t value) {
  _internal_set_clientid(value);
  // @@protoc_insertion_point(field_set:CMsgVDebugGameSessionIDEvent.clientid)
}

// optional string gamesessionid = 2;
inline bool CMsgVDebugGameSessionIDEvent::_internal_has_gamesessionid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgVDebugGameSessionIDEvent::has_gamesessionid() const {
  return _internal_has_gamesessionid();
}
inline void CMsgVDebugGameSessionIDEvent::clear_gamesessionid() {
  _impl_.gamesessionid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgVDebugGameSessionIDEvent::gamesessionid() const {
  // @@protoc_insertion_point(field_get:CMsgVDebugGameSessionIDEvent.gamesessionid)
  return _internal_gamesessionid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgVDebugGameSessionIDEvent::set_gamesessionid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.gamesessionid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgVDebugGameSessionIDEvent.gamesessionid)
}
inline std::string* CMsgVDebugGameSessionIDEvent::mutable_gamesessionid() {
  std::string* _s = _internal_mutable_gamesessionid();
  // @@protoc_insertion_point(field_mutable:CMsgVDebugGameSessionIDEvent.gamesessionid)
  return _s;
}
inline const std::string& CMsgVDebugGameSessionIDEvent::_internal_gamesessionid() const {
  return _impl_.gamesessionid_.Get();
}
inline void CMsgVDebugGameSessionIDEvent::_internal_set_gamesessionid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.gamesessionid_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgVDebugGameSessionIDEvent::_internal_mutable_gamesessionid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.gamesessionid_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgVDebugGameSessionIDEvent::release_gamesessionid() {
  // @@protoc_insertion_point(field_release:CMsgVDebugGameSessionIDEvent.gamesessionid)
  if (!_internal_has_gamesessionid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.gamesessionid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.gamesessionid_.IsDefault()) {
    _impl_.gamesessionid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgVDebugGameSessionIDEvent::set_allocated_gamesessionid(std::string* gamesessionid) {
  if (gamesessionid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.gamesessionid_.SetAllocated(gamesessionid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.gamesessionid_.IsDefault()) {
    _impl_.gamesessionid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgVDebugGameSessionIDEvent.gamesessionid)
}

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

// CMsgPlaceDecalEvent

// optional .CMsgVector position = 1;
inline bool CMsgPlaceDecalEvent::_internal_has_position() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr);
  return value;
}
inline bool CMsgPlaceDecalEvent::has_position() const {
  return _internal_has_position();
}
inline const ::CMsgVector& CMsgPlaceDecalEvent::_internal_position() const {
  const ::CMsgVector* p = _impl_.position_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgPlaceDecalEvent::position() const {
  // @@protoc_insertion_point(field_get:CMsgPlaceDecalEvent.position)
  return _internal_position();
}
inline void CMsgPlaceDecalEvent::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:CMsgPlaceDecalEvent.position)
}
inline ::CMsgVector* CMsgPlaceDecalEvent::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* CMsgPlaceDecalEvent::unsafe_arena_release_position() {
  // @@protoc_insertion_point(field_release:CMsgPlaceDecalEvent.position)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.position_;
  _impl_.position_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgPlaceDecalEvent::_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* CMsgPlaceDecalEvent::mutable_position() {
  ::CMsgVector* _msg = _internal_mutable_position();
  // @@protoc_insertion_point(field_mutable:CMsgPlaceDecalEvent.position)
  return _msg;
}
inline void CMsgPlaceDecalEvent::set_allocated_position(::CMsgVector* position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.position_);
  }
  if (position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(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:CMsgPlaceDecalEvent.position)
}

// optional .CMsgVector normal = 2;
inline bool CMsgPlaceDecalEvent::_internal_has_normal() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.normal_ != nullptr);
  return value;
}
inline bool CMsgPlaceDecalEvent::has_normal() const {
  return _internal_has_normal();
}
inline const ::CMsgVector& CMsgPlaceDecalEvent::_internal_normal() const {
  const ::CMsgVector* p = _impl_.normal_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgPlaceDecalEvent::normal() const {
  // @@protoc_insertion_point(field_get:CMsgPlaceDecalEvent.normal)
  return _internal_normal();
}
inline void CMsgPlaceDecalEvent::unsafe_arena_set_allocated_normal(
    ::CMsgVector* normal) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.normal_);
  }
  _impl_.normal_ = normal;
  if (normal) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgPlaceDecalEvent.normal)
}
inline ::CMsgVector* CMsgPlaceDecalEvent::release_normal() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.normal_;
  _impl_.normal_ = 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* CMsgPlaceDecalEvent::unsafe_arena_release_normal() {
  // @@protoc_insertion_point(field_release:CMsgPlaceDecalEvent.normal)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.normal_;
  _impl_.normal_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgPlaceDecalEvent::_internal_mutable_normal() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.normal_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.normal_ = p;
  }
  return _impl_.normal_;
}
inline ::CMsgVector* CMsgPlaceDecalEvent::mutable_normal() {
  ::CMsgVector* _msg = _internal_mutable_normal();
  // @@protoc_insertion_point(field_mutable:CMsgPlaceDecalEvent.normal)
  return _msg;
}
inline void CMsgPlaceDecalEvent::set_allocated_normal(::CMsgVector* normal) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.normal_);
  }
  if (normal) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(normal));
    if (message_arena != submessage_arena) {
      normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, normal, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.normal_ = normal;
  // @@protoc_insertion_point(field_set_allocated:CMsgPlaceDecalEvent.normal)
}

// optional .CMsgVector saxis = 3;
inline bool CMsgPlaceDecalEvent::_internal_has_saxis() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.saxis_ != nullptr);
  return value;
}
inline bool CMsgPlaceDecalEvent::has_saxis() const {
  return _internal_has_saxis();
}
inline const ::CMsgVector& CMsgPlaceDecalEvent::_internal_saxis() const {
  const ::CMsgVector* p = _impl_.saxis_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgPlaceDecalEvent::saxis() const {
  // @@protoc_insertion_point(field_get:CMsgPlaceDecalEvent.saxis)
  return _internal_saxis();
}
inline void CMsgPlaceDecalEvent::unsafe_arena_set_allocated_saxis(
    ::CMsgVector* saxis) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.saxis_);
  }
  _impl_.saxis_ = saxis;
  if (saxis) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgPlaceDecalEvent.saxis)
}
inline ::CMsgVector* CMsgPlaceDecalEvent::release_saxis() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.saxis_;
  _impl_.saxis_ = 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* CMsgPlaceDecalEvent::unsafe_arena_release_saxis() {
  // @@protoc_insertion_point(field_release:CMsgPlaceDecalEvent.saxis)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.saxis_;
  _impl_.saxis_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgPlaceDecalEvent::_internal_mutable_saxis() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.saxis_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.saxis_ = p;
  }
  return _impl_.saxis_;
}
inline ::CMsgVector* CMsgPlaceDecalEvent::mutable_saxis() {
  ::CMsgVector* _msg = _internal_mutable_saxis();
  // @@protoc_insertion_point(field_mutable:CMsgPlaceDecalEvent.saxis)
  return _msg;
}
inline void CMsgPlaceDecalEvent::set_allocated_saxis(::CMsgVector* saxis) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.saxis_);
  }
  if (saxis) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(saxis));
    if (message_arena != submessage_arena) {
      saxis = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, saxis, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.saxis_ = saxis;
  // @@protoc_insertion_point(field_set_allocated:CMsgPlaceDecalEvent.saxis)
}

// optional int32 boneindex = 4;
inline bool CMsgPlaceDecalEvent::_internal_has_boneindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgPlaceDecalEvent::has_boneindex() const {
  return _internal_has_boneindex();
}
inline void CMsgPlaceDecalEvent::clear_boneindex() {
  _impl_.boneindex_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CMsgPlaceDecalEvent::_internal_boneindex() const {
  return _impl_.boneindex_;
}
inline int32_t CMsgPlaceDecalEvent::boneindex() const {
  // @@protoc_insertion_point(field_get:CMsgPlaceDecalEvent.boneindex)
  return _internal_boneindex();
}
inline void CMsgPlaceDecalEvent::_internal_set_boneindex(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.boneindex_ = value;
}
inline void CMsgPlaceDecalEvent::set_boneindex(int32_t value) {
  _internal_set_boneindex(value);
  // @@protoc_insertion_point(field_set:CMsgPlaceDecalEvent.boneindex)
}

// optional int32 triangleindex = 13;
inline bool CMsgPlaceDecalEvent::_internal_has_triangleindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CMsgPlaceDecalEvent::has_triangleindex() const {
  return _internal_has_triangleindex();
}
inline void CMsgPlaceDecalEvent::clear_triangleindex() {
  _impl_.triangleindex_ = 0;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline int32_t CMsgPlaceDecalEvent::_internal_triangleindex() const {
  return _impl_.triangleindex_;
}
inline int32_t CMsgPlaceDecalEvent::triangleindex() const {
  // @@protoc_insertion_point(field_get:CMsgPlaceDecalEvent.triangleindex)
  return _internal_triangleindex();
}
inline void CMsgPlaceDecalEvent::_internal_set_triangleindex(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.triangleindex_ = value;
}
inline void CMsgPlaceDecalEvent::set_triangleindex(int32_t value) {
  _internal_set_triangleindex(value);
  // @@protoc_insertion_point(field_set:CMsgPlaceDecalEvent.triangleindex)
}

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

// optional fixed32 color = 6;
inline bool CMsgPlaceDecalEvent::_internal_has_color() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgPlaceDecalEvent::has_color() const {
  return _internal_has_color();
}
inline void CMsgPlaceDecalEvent::clear_color() {
  _impl_.color_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgPlaceDecalEvent::_internal_color() const {
  return _impl_.color_;
}
inline uint32_t CMsgPlaceDecalEvent::color() const {
  // @@protoc_insertion_point(field_get:CMsgPlaceDecalEvent.color)
  return _internal_color();
}
inline void CMsgPlaceDecalEvent::_internal_set_color(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.color_ = value;
}
inline void CMsgPlaceDecalEvent::set_color(uint32_t value) {
  _internal_set_color(value);
  // @@protoc_insertion_point(field_set:CMsgPlaceDecalEvent.color)
}

// optional int32 random_seed = 7;
inline bool CMsgPlaceDecalEvent::_internal_has_random_seed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgPlaceDecalEvent::has_random_seed() const {
  return _internal_has_random_seed();
}
inline void CMsgPlaceDecalEvent::clear_random_seed() {
  _impl_.random_seed_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int32_t CMsgPlaceDecalEvent::_internal_random_seed() const {
  return _impl_.random_seed_;
}
inline int32_t CMsgPlaceDecalEvent::random_seed() const {
  // @@protoc_insertion_point(field_get:CMsgPlaceDecalEvent.random_seed)
  return _internal_random_seed();
}
inline void CMsgPlaceDecalEvent::_internal_set_random_seed(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.random_seed_ = value;
}
inline void CMsgPlaceDecalEvent::set_random_seed(int32_t value) {
  _internal_set_random_seed(value);
  // @@protoc_insertion_point(field_set:CMsgPlaceDecalEvent.random_seed)
}

// optional uint32 decal_group_name = 8;
inline bool CMsgPlaceDecalEvent::_internal_has_decal_group_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgPlaceDecalEvent::has_decal_group_name() const {
  return _internal_has_decal_group_name();
}
inline void CMsgPlaceDecalEvent::clear_decal_group_name() {
  _impl_.decal_group_name_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgPlaceDecalEvent::_internal_decal_group_name() const {
  return _impl_.decal_group_name_;
}
inline uint32_t CMsgPlaceDecalEvent::decal_group_name() const {
  // @@protoc_insertion_point(field_get:CMsgPlaceDecalEvent.decal_group_name)
  return _internal_decal_group_name();
}
inline void CMsgPlaceDecalEvent::_internal_set_decal_group_name(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.decal_group_name_ = value;
}
inline void CMsgPlaceDecalEvent::set_decal_group_name(uint32_t value) {
  _internal_set_decal_group_name(value);
  // @@protoc_insertion_point(field_set:CMsgPlaceDecalEvent.decal_group_name)
}

// optional float size_override = 9;
inline bool CMsgPlaceDecalEvent::_internal_has_size_override() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgPlaceDecalEvent::has_size_override() const {
  return _internal_has_size_override();
}
inline void CMsgPlaceDecalEvent::clear_size_override() {
  _impl_.size_override_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline float CMsgPlaceDecalEvent::_internal_size_override() const {
  return _impl_.size_override_;
}
inline float CMsgPlaceDecalEvent::size_override() const {
  // @@protoc_insertion_point(field_get:CMsgPlaceDecalEvent.size_override)
  return _internal_size_override();
}
inline void CMsgPlaceDecalEvent::_internal_set_size_override(float value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.size_override_ = value;
}
inline void CMsgPlaceDecalEvent::set_size_override(float value) {
  _internal_set_size_override(value);
  // @@protoc_insertion_point(field_set:CMsgPlaceDecalEvent.size_override)
}

// optional uint32 entityhandle = 10 [default = 16777215];
inline bool CMsgPlaceDecalEvent::_internal_has_entityhandle() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CMsgPlaceDecalEvent::has_entityhandle() const {
  return _internal_has_entityhandle();
}
inline void CMsgPlaceDecalEvent::clear_entityhandle() {
  _impl_.entityhandle_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t CMsgPlaceDecalEvent::_internal_entityhandle() const {
  return _impl_.entityhandle_;
}
inline uint32_t CMsgPlaceDecalEvent::entityhandle() const {
  // @@protoc_insertion_point(field_get:CMsgPlaceDecalEvent.entityhandle)
  return _internal_entityhandle();
}
inline void CMsgPlaceDecalEvent::_internal_set_entityhandle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.entityhandle_ = value;
}
inline void CMsgPlaceDecalEvent::set_entityhandle(uint32_t value) {
  _internal_set_entityhandle(value);
  // @@protoc_insertion_point(field_set:CMsgPlaceDecalEvent.entityhandle)
}

// optional uint64 material_id = 11;
inline bool CMsgPlaceDecalEvent::_internal_has_material_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgPlaceDecalEvent::has_material_id() const {
  return _internal_has_material_id();
}
inline void CMsgPlaceDecalEvent::clear_material_id() {
  _impl_.material_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint64_t CMsgPlaceDecalEvent::_internal_material_id() const {
  return _impl_.material_id_;
}
inline uint64_t CMsgPlaceDecalEvent::material_id() const {
  // @@protoc_insertion_point(field_get:CMsgPlaceDecalEvent.material_id)
  return _internal_material_id();
}
inline void CMsgPlaceDecalEvent::_internal_set_material_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.material_id_ = value;
}
inline void CMsgPlaceDecalEvent::set_material_id(uint64_t value) {
  _internal_set_material_id(value);
  // @@protoc_insertion_point(field_set:CMsgPlaceDecalEvent.material_id)
}

// optional uint32 sequence_name = 12;
inline bool CMsgPlaceDecalEvent::_internal_has_sequence_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgPlaceDecalEvent::has_sequence_name() const {
  return _internal_has_sequence_name();
}
inline void CMsgPlaceDecalEvent::clear_sequence_name() {
  _impl_.sequence_name_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CMsgPlaceDecalEvent::_internal_sequence_name() const {
  return _impl_.sequence_name_;
}
inline uint32_t CMsgPlaceDecalEvent::sequence_name() const {
  // @@protoc_insertion_point(field_get:CMsgPlaceDecalEvent.sequence_name)
  return _internal_sequence_name();
}
inline void CMsgPlaceDecalEvent::_internal_set_sequence_name(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.sequence_name_ = value;
}
inline void CMsgPlaceDecalEvent::set_sequence_name(uint32_t value) {
  _internal_set_sequence_name(value);
  // @@protoc_insertion_point(field_set:CMsgPlaceDecalEvent.sequence_name)
}

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

// CMsgClearWorldDecalsEvent

// optional uint32 flagstoclear = 1;
inline bool CMsgClearWorldDecalsEvent::_internal_has_flagstoclear() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgClearWorldDecalsEvent::has_flagstoclear() const {
  return _internal_has_flagstoclear();
}
inline void CMsgClearWorldDecalsEvent::clear_flagstoclear() {
  _impl_.flagstoclear_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgClearWorldDecalsEvent::_internal_flagstoclear() const {
  return _impl_.flagstoclear_;
}
inline uint32_t CMsgClearWorldDecalsEvent::flagstoclear() const {
  // @@protoc_insertion_point(field_get:CMsgClearWorldDecalsEvent.flagstoclear)
  return _internal_flagstoclear();
}
inline void CMsgClearWorldDecalsEvent::_internal_set_flagstoclear(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.flagstoclear_ = value;
}
inline void CMsgClearWorldDecalsEvent::set_flagstoclear(uint32_t value) {
  _internal_set_flagstoclear(value);
  // @@protoc_insertion_point(field_set:CMsgClearWorldDecalsEvent.flagstoclear)
}

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

// CMsgClearEntityDecalsEvent

// optional uint32 flagstoclear = 1;
inline bool CMsgClearEntityDecalsEvent::_internal_has_flagstoclear() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgClearEntityDecalsEvent::has_flagstoclear() const {
  return _internal_has_flagstoclear();
}
inline void CMsgClearEntityDecalsEvent::clear_flagstoclear() {
  _impl_.flagstoclear_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgClearEntityDecalsEvent::_internal_flagstoclear() const {
  return _impl_.flagstoclear_;
}
inline uint32_t CMsgClearEntityDecalsEvent::flagstoclear() const {
  // @@protoc_insertion_point(field_get:CMsgClearEntityDecalsEvent.flagstoclear)
  return _internal_flagstoclear();
}
inline void CMsgClearEntityDecalsEvent::_internal_set_flagstoclear(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.flagstoclear_ = value;
}
inline void CMsgClearEntityDecalsEvent::set_flagstoclear(uint32_t value) {
  _internal_set_flagstoclear(value);
  // @@protoc_insertion_point(field_set:CMsgClearEntityDecalsEvent.flagstoclear)
}

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

// CMsgClearDecalsForEntityEvent

// optional uint32 flagstoclear = 1;
inline bool CMsgClearDecalsForEntityEvent::_internal_has_flagstoclear() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgClearDecalsForEntityEvent::has_flagstoclear() const {
  return _internal_has_flagstoclear();
}
inline void CMsgClearDecalsForEntityEvent::clear_flagstoclear() {
  _impl_.flagstoclear_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgClearDecalsForEntityEvent::_internal_flagstoclear() const {
  return _impl_.flagstoclear_;
}
inline uint32_t CMsgClearDecalsForEntityEvent::flagstoclear() const {
  // @@protoc_insertion_point(field_get:CMsgClearDecalsForEntityEvent.flagstoclear)
  return _internal_flagstoclear();
}
inline void CMsgClearDecalsForEntityEvent::_internal_set_flagstoclear(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.flagstoclear_ = value;
}
inline void CMsgClearDecalsForEntityEvent::set_flagstoclear(uint32_t value) {
  _internal_set_flagstoclear(value);
  // @@protoc_insertion_point(field_set:CMsgClearDecalsForEntityEvent.flagstoclear)
}

// optional uint32 entityhandle = 2 [default = 16777215];
inline bool CMsgClearDecalsForEntityEvent::_internal_has_entityhandle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgClearDecalsForEntityEvent::has_entityhandle() const {
  return _internal_has_entityhandle();
}
inline void CMsgClearDecalsForEntityEvent::clear_entityhandle() {
  _impl_.entityhandle_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgClearDecalsForEntityEvent::_internal_entityhandle() const {
  return _impl_.entityhandle_;
}
inline uint32_t CMsgClearDecalsForEntityEvent::entityhandle() const {
  // @@protoc_insertion_point(field_get:CMsgClearDecalsForEntityEvent.entityhandle)
  return _internal_entityhandle();
}
inline void CMsgClearDecalsForEntityEvent::_internal_set_entityhandle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.entityhandle_ = value;
}
inline void CMsgClearDecalsForEntityEvent::set_entityhandle(uint32_t value) {
  _internal_set_entityhandle(value);
  // @@protoc_insertion_point(field_set:CMsgClearDecalsForEntityEvent.entityhandle)
}

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

// CMsgSource1LegacyGameEventList_key_t

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

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

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

// CMsgSource1LegacyGameEventList_descriptor_t

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

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

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

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

// CMsgSource1LegacyGameEventList

// repeated .CMsgSource1LegacyGameEventList.descriptor_t descriptors = 1;
inline int CMsgSource1LegacyGameEventList::_internal_descriptors_size() const {
  return _impl_.descriptors_.size();
}
inline int CMsgSource1LegacyGameEventList::descriptors_size() const {
  return _internal_descriptors_size();
}
inline void CMsgSource1LegacyGameEventList::clear_descriptors() {
  _impl_.descriptors_.Clear();
}
inline ::CMsgSource1LegacyGameEventList_descriptor_t* CMsgSource1LegacyGameEventList::mutable_descriptors(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgSource1LegacyGameEventList.descriptors)
  return _impl_.descriptors_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSource1LegacyGameEventList_descriptor_t >*
CMsgSource1LegacyGameEventList::mutable_descriptors() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSource1LegacyGameEventList.descriptors)
  return &_impl_.descriptors_;
}
inline const ::CMsgSource1LegacyGameEventList_descriptor_t& CMsgSource1LegacyGameEventList::_internal_descriptors(int index) const {
  return _impl_.descriptors_.Get(index);
}
inline const ::CMsgSource1LegacyGameEventList_descriptor_t& CMsgSource1LegacyGameEventList::descriptors(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSource1LegacyGameEventList.descriptors)
  return _internal_descriptors(index);
}
inline ::CMsgSource1LegacyGameEventList_descriptor_t* CMsgSource1LegacyGameEventList::_internal_add_descriptors() {
  return _impl_.descriptors_.Add();
}
inline ::CMsgSource1LegacyGameEventList_descriptor_t* CMsgSource1LegacyGameEventList::add_descriptors() {
  ::CMsgSource1LegacyGameEventList_descriptor_t* _add = _internal_add_descriptors();
  // @@protoc_insertion_point(field_add:CMsgSource1LegacyGameEventList.descriptors)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSource1LegacyGameEventList_descriptor_t >&
CMsgSource1LegacyGameEventList::descriptors() const {
  // @@protoc_insertion_point(field_list:CMsgSource1LegacyGameEventList.descriptors)
  return _impl_.descriptors_;
}

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

// CMsgSource1LegacyListenEvents

// optional int32 playerslot = 1;
inline bool CMsgSource1LegacyListenEvents::_internal_has_playerslot() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSource1LegacyListenEvents::has_playerslot() const {
  return _internal_has_playerslot();
}
inline void CMsgSource1LegacyListenEvents::clear_playerslot() {
  _impl_.playerslot_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CMsgSource1LegacyListenEvents::_internal_playerslot() const {
  return _impl_.playerslot_;
}
inline int32_t CMsgSource1LegacyListenEvents::playerslot() const {
  // @@protoc_insertion_point(field_get:CMsgSource1LegacyListenEvents.playerslot)
  return _internal_playerslot();
}
inline void CMsgSource1LegacyListenEvents::_internal_set_playerslot(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.playerslot_ = value;
}
inline void CMsgSource1LegacyListenEvents::set_playerslot(int32_t value) {
  _internal_set_playerslot(value);
  // @@protoc_insertion_point(field_set:CMsgSource1LegacyListenEvents.playerslot)
}

// repeated uint32 eventarraybits = 2;
inline int CMsgSource1LegacyListenEvents::_internal_eventarraybits_size() const {
  return _impl_.eventarraybits_.size();
}
inline int CMsgSource1LegacyListenEvents::eventarraybits_size() const {
  return _internal_eventarraybits_size();
}
inline void CMsgSource1LegacyListenEvents::clear_eventarraybits() {
  _impl_.eventarraybits_.Clear();
}
inline uint32_t CMsgSource1LegacyListenEvents::_internal_eventarraybits(int index) const {
  return _impl_.eventarraybits_.Get(index);
}
inline uint32_t CMsgSource1LegacyListenEvents::eventarraybits(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSource1LegacyListenEvents.eventarraybits)
  return _internal_eventarraybits(index);
}
inline void CMsgSource1LegacyListenEvents::set_eventarraybits(int index, uint32_t value) {
  _impl_.eventarraybits_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSource1LegacyListenEvents.eventarraybits)
}
inline void CMsgSource1LegacyListenEvents::_internal_add_eventarraybits(uint32_t value) {
  _impl_.eventarraybits_.Add(value);
}
inline void CMsgSource1LegacyListenEvents::add_eventarraybits(uint32_t value) {
  _internal_add_eventarraybits(value);
  // @@protoc_insertion_point(field_add:CMsgSource1LegacyListenEvents.eventarraybits)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSource1LegacyListenEvents::_internal_eventarraybits() const {
  return _impl_.eventarraybits_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSource1LegacyListenEvents::eventarraybits() const {
  // @@protoc_insertion_point(field_list:CMsgSource1LegacyListenEvents.eventarraybits)
  return _internal_eventarraybits();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSource1LegacyListenEvents::_internal_mutable_eventarraybits() {
  return &_impl_.eventarraybits_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSource1LegacyListenEvents::mutable_eventarraybits() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSource1LegacyListenEvents.eventarraybits)
  return _internal_mutable_eventarraybits();
}

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

// CMsgSource1LegacyGameEvent_key_t

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

// optional string val_string = 2;
inline bool CMsgSource1LegacyGameEvent_key_t::_internal_has_val_string() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSource1LegacyGameEvent_key_t::has_val_string() const {
  return _internal_has_val_string();
}
inline void CMsgSource1LegacyGameEvent_key_t::clear_val_string() {
  _impl_.val_string_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSource1LegacyGameEvent_key_t::val_string() const {
  // @@protoc_insertion_point(field_get:CMsgSource1LegacyGameEvent.key_t.val_string)
  return _internal_val_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSource1LegacyGameEvent_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:CMsgSource1LegacyGameEvent.key_t.val_string)
}
inline std::string* CMsgSource1LegacyGameEvent_key_t::mutable_val_string() {
  std::string* _s = _internal_mutable_val_string();
  // @@protoc_insertion_point(field_mutable:CMsgSource1LegacyGameEvent.key_t.val_string)
  return _s;
}
inline const std::string& CMsgSource1LegacyGameEvent_key_t::_internal_val_string() const {
  return _impl_.val_string_.Get();
}
inline void CMsgSource1LegacyGameEvent_key_t::_internal_set_val_string(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.val_string_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSource1LegacyGameEvent_key_t::_internal_mutable_val_string() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.val_string_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSource1LegacyGameEvent_key_t::release_val_string() {
  // @@protoc_insertion_point(field_release:CMsgSource1LegacyGameEvent.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 CMsgSource1LegacyGameEvent_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:CMsgSource1LegacyGameEvent.key_t.val_string)
}

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

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

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

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

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

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

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

// CMsgSource1LegacyGameEvent

// optional string event_name = 1;
inline bool CMsgSource1LegacyGameEvent::_internal_has_event_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSource1LegacyGameEvent::has_event_name() const {
  return _internal_has_event_name();
}
inline void CMsgSource1LegacyGameEvent::clear_event_name() {
  _impl_.event_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSource1LegacyGameEvent::event_name() const {
  // @@protoc_insertion_point(field_get:CMsgSource1LegacyGameEvent.event_name)
  return _internal_event_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSource1LegacyGameEvent::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:CMsgSource1LegacyGameEvent.event_name)
}
inline std::string* CMsgSource1LegacyGameEvent::mutable_event_name() {
  std::string* _s = _internal_mutable_event_name();
  // @@protoc_insertion_point(field_mutable:CMsgSource1LegacyGameEvent.event_name)
  return _s;
}
inline const std::string& CMsgSource1LegacyGameEvent::_internal_event_name() const {
  return _impl_.event_name_.Get();
}
inline void CMsgSource1LegacyGameEvent::_internal_set_event_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.event_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSource1LegacyGameEvent::_internal_mutable_event_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.event_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSource1LegacyGameEvent::release_event_name() {
  // @@protoc_insertion_point(field_release:CMsgSource1LegacyGameEvent.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 CMsgSource1LegacyGameEvent::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:CMsgSource1LegacyGameEvent.event_name)
}

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

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

// optional int32 server_tick = 4;
inline bool CMsgSource1LegacyGameEvent::_internal_has_server_tick() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSource1LegacyGameEvent::has_server_tick() const {
  return _internal_has_server_tick();
}
inline void CMsgSource1LegacyGameEvent::clear_server_tick() {
  _impl_.server_tick_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CMsgSource1LegacyGameEvent::_internal_server_tick() const {
  return _impl_.server_tick_;
}
inline int32_t CMsgSource1LegacyGameEvent::server_tick() const {
  // @@protoc_insertion_point(field_get:CMsgSource1LegacyGameEvent.server_tick)
  return _internal_server_tick();
}
inline void CMsgSource1LegacyGameEvent::_internal_set_server_tick(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.server_tick_ = value;
}
inline void CMsgSource1LegacyGameEvent::set_server_tick(int32_t value) {
  _internal_set_server_tick(value);
  // @@protoc_insertion_point(field_set:CMsgSource1LegacyGameEvent.server_tick)
}

// optional int32 passthrough = 5;
inline bool CMsgSource1LegacyGameEvent::_internal_has_passthrough() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSource1LegacyGameEvent::has_passthrough() const {
  return _internal_has_passthrough();
}
inline void CMsgSource1LegacyGameEvent::clear_passthrough() {
  _impl_.passthrough_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CMsgSource1LegacyGameEvent::_internal_passthrough() const {
  return _impl_.passthrough_;
}
inline int32_t CMsgSource1LegacyGameEvent::passthrough() const {
  // @@protoc_insertion_point(field_get:CMsgSource1LegacyGameEvent.passthrough)
  return _internal_passthrough();
}
inline void CMsgSource1LegacyGameEvent::_internal_set_passthrough(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.passthrough_ = value;
}
inline void CMsgSource1LegacyGameEvent::set_passthrough(int32_t value) {
  _internal_set_passthrough(value);
  // @@protoc_insertion_point(field_set:CMsgSource1LegacyGameEvent.passthrough)
}

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

// CMsgSosStartSoundEvent

// optional int32 soundevent_guid = 1;
inline bool CMsgSosStartSoundEvent::_internal_has_soundevent_guid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSosStartSoundEvent::has_soundevent_guid() const {
  return _internal_has_soundevent_guid();
}
inline void CMsgSosStartSoundEvent::clear_soundevent_guid() {
  _impl_.soundevent_guid_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CMsgSosStartSoundEvent::_internal_soundevent_guid() const {
  return _impl_.soundevent_guid_;
}
inline int32_t CMsgSosStartSoundEvent::soundevent_guid() const {
  // @@protoc_insertion_point(field_get:CMsgSosStartSoundEvent.soundevent_guid)
  return _internal_soundevent_guid();
}
inline void CMsgSosStartSoundEvent::_internal_set_soundevent_guid(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.soundevent_guid_ = value;
}
inline void CMsgSosStartSoundEvent::set_soundevent_guid(int32_t value) {
  _internal_set_soundevent_guid(value);
  // @@protoc_insertion_point(field_set:CMsgSosStartSoundEvent.soundevent_guid)
}

// optional fixed32 soundevent_hash = 2;
inline bool CMsgSosStartSoundEvent::_internal_has_soundevent_hash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSosStartSoundEvent::has_soundevent_hash() const {
  return _internal_has_soundevent_hash();
}
inline void CMsgSosStartSoundEvent::clear_soundevent_hash() {
  _impl_.soundevent_hash_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSosStartSoundEvent::_internal_soundevent_hash() const {
  return _impl_.soundevent_hash_;
}
inline uint32_t CMsgSosStartSoundEvent::soundevent_hash() const {
  // @@protoc_insertion_point(field_get:CMsgSosStartSoundEvent.soundevent_hash)
  return _internal_soundevent_hash();
}
inline void CMsgSosStartSoundEvent::_internal_set_soundevent_hash(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.soundevent_hash_ = value;
}
inline void CMsgSosStartSoundEvent::set_soundevent_hash(uint32_t value) {
  _internal_set_soundevent_hash(value);
  // @@protoc_insertion_point(field_set:CMsgSosStartSoundEvent.soundevent_hash)
}

// optional int32 source_entity_index = 3 [default = -1];
inline bool CMsgSosStartSoundEvent::_internal_has_source_entity_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSosStartSoundEvent::has_source_entity_index() const {
  return _internal_has_source_entity_index();
}
inline void CMsgSosStartSoundEvent::clear_source_entity_index() {
  _impl_.source_entity_index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CMsgSosStartSoundEvent::_internal_source_entity_index() const {
  return _impl_.source_entity_index_;
}
inline int32_t CMsgSosStartSoundEvent::source_entity_index() const {
  // @@protoc_insertion_point(field_get:CMsgSosStartSoundEvent.source_entity_index)
  return _internal_source_entity_index();
}
inline void CMsgSosStartSoundEvent::_internal_set_source_entity_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.source_entity_index_ = value;
}
inline void CMsgSosStartSoundEvent::set_source_entity_index(int32_t value) {
  _internal_set_source_entity_index(value);
  // @@protoc_insertion_point(field_set:CMsgSosStartSoundEvent.source_entity_index)
}

// optional int32 seed = 4;
inline bool CMsgSosStartSoundEvent::_internal_has_seed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSosStartSoundEvent::has_seed() const {
  return _internal_has_seed();
}
inline void CMsgSosStartSoundEvent::clear_seed() {
  _impl_.seed_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t CMsgSosStartSoundEvent::_internal_seed() const {
  return _impl_.seed_;
}
inline int32_t CMsgSosStartSoundEvent::seed() const {
  // @@protoc_insertion_point(field_get:CMsgSosStartSoundEvent.seed)
  return _internal_seed();
}
inline void CMsgSosStartSoundEvent::_internal_set_seed(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.seed_ = value;
}
inline void CMsgSosStartSoundEvent::set_seed(int32_t value) {
  _internal_set_seed(value);
  // @@protoc_insertion_point(field_set:CMsgSosStartSoundEvent.seed)
}

// optional bytes packed_params = 5;
inline bool CMsgSosStartSoundEvent::_internal_has_packed_params() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSosStartSoundEvent::has_packed_params() const {
  return _internal_has_packed_params();
}
inline void CMsgSosStartSoundEvent::clear_packed_params() {
  _impl_.packed_params_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSosStartSoundEvent::packed_params() const {
  // @@protoc_insertion_point(field_get:CMsgSosStartSoundEvent.packed_params)
  return _internal_packed_params();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSosStartSoundEvent::set_packed_params(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.packed_params_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSosStartSoundEvent.packed_params)
}
inline std::string* CMsgSosStartSoundEvent::mutable_packed_params() {
  std::string* _s = _internal_mutable_packed_params();
  // @@protoc_insertion_point(field_mutable:CMsgSosStartSoundEvent.packed_params)
  return _s;
}
inline const std::string& CMsgSosStartSoundEvent::_internal_packed_params() const {
  return _impl_.packed_params_.Get();
}
inline void CMsgSosStartSoundEvent::_internal_set_packed_params(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.packed_params_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSosStartSoundEvent::_internal_mutable_packed_params() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.packed_params_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSosStartSoundEvent::release_packed_params() {
  // @@protoc_insertion_point(field_release:CMsgSosStartSoundEvent.packed_params)
  if (!_internal_has_packed_params()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.packed_params_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.packed_params_.IsDefault()) {
    _impl_.packed_params_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSosStartSoundEvent::set_allocated_packed_params(std::string* packed_params) {
  if (packed_params != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.packed_params_.SetAllocated(packed_params, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.packed_params_.IsDefault()) {
    _impl_.packed_params_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSosStartSoundEvent.packed_params)
}

// optional float start_time = 6;
inline bool CMsgSosStartSoundEvent::_internal_has_start_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSosStartSoundEvent::has_start_time() const {
  return _internal_has_start_time();
}
inline void CMsgSosStartSoundEvent::clear_start_time() {
  _impl_.start_time_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float CMsgSosStartSoundEvent::_internal_start_time() const {
  return _impl_.start_time_;
}
inline float CMsgSosStartSoundEvent::start_time() const {
  // @@protoc_insertion_point(field_get:CMsgSosStartSoundEvent.start_time)
  return _internal_start_time();
}
inline void CMsgSosStartSoundEvent::_internal_set_start_time(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.start_time_ = value;
}
inline void CMsgSosStartSoundEvent::set_start_time(float value) {
  _internal_set_start_time(value);
  // @@protoc_insertion_point(field_set:CMsgSosStartSoundEvent.start_time)
}

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

// CMsgSosStopSoundEvent

// optional int32 soundevent_guid = 1;
inline bool CMsgSosStopSoundEvent::_internal_has_soundevent_guid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSosStopSoundEvent::has_soundevent_guid() const {
  return _internal_has_soundevent_guid();
}
inline void CMsgSosStopSoundEvent::clear_soundevent_guid() {
  _impl_.soundevent_guid_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t CMsgSosStopSoundEvent::_internal_soundevent_guid() const {
  return _impl_.soundevent_guid_;
}
inline int32_t CMsgSosStopSoundEvent::soundevent_guid() const {
  // @@protoc_insertion_point(field_get:CMsgSosStopSoundEvent.soundevent_guid)
  return _internal_soundevent_guid();
}
inline void CMsgSosStopSoundEvent::_internal_set_soundevent_guid(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.soundevent_guid_ = value;
}
inline void CMsgSosStopSoundEvent::set_soundevent_guid(int32_t value) {
  _internal_set_soundevent_guid(value);
  // @@protoc_insertion_point(field_set:CMsgSosStopSoundEvent.soundevent_guid)
}

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

// CMsgSosStopSoundEventHash

// optional fixed32 soundevent_hash = 1;
inline bool CMsgSosStopSoundEventHash::_internal_has_soundevent_hash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSosStopSoundEventHash::has_soundevent_hash() const {
  return _internal_has_soundevent_hash();
}
inline void CMsgSosStopSoundEventHash::clear_soundevent_hash() {
  _impl_.soundevent_hash_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgSosStopSoundEventHash::_internal_soundevent_hash() const {
  return _impl_.soundevent_hash_;
}
inline uint32_t CMsgSosStopSoundEventHash::soundevent_hash() const {
  // @@protoc_insertion_point(field_get:CMsgSosStopSoundEventHash.soundevent_hash)
  return _internal_soundevent_hash();
}
inline void CMsgSosStopSoundEventHash::_internal_set_soundevent_hash(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.soundevent_hash_ = value;
}
inline void CMsgSosStopSoundEventHash::set_soundevent_hash(uint32_t value) {
  _internal_set_soundevent_hash(value);
  // @@protoc_insertion_point(field_set:CMsgSosStopSoundEventHash.soundevent_hash)
}

// optional int32 source_entity_index = 2 [default = -1];
inline bool CMsgSosStopSoundEventHash::_internal_has_source_entity_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSosStopSoundEventHash::has_source_entity_index() const {
  return _internal_has_source_entity_index();
}
inline void CMsgSosStopSoundEventHash::clear_source_entity_index() {
  _impl_.source_entity_index_ = -1;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CMsgSosStopSoundEventHash::_internal_source_entity_index() const {
  return _impl_.source_entity_index_;
}
inline int32_t CMsgSosStopSoundEventHash::source_entity_index() const {
  // @@protoc_insertion_point(field_get:CMsgSosStopSoundEventHash.source_entity_index)
  return _internal_source_entity_index();
}
inline void CMsgSosStopSoundEventHash::_internal_set_source_entity_index(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.source_entity_index_ = value;
}
inline void CMsgSosStopSoundEventHash::set_source_entity_index(int32_t value) {
  _internal_set_source_entity_index(value);
  // @@protoc_insertion_point(field_set:CMsgSosStopSoundEventHash.source_entity_index)
}

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

// CMsgSosSetSoundEventParams

// optional int32 soundevent_guid = 1;
inline bool CMsgSosSetSoundEventParams::_internal_has_soundevent_guid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSosSetSoundEventParams::has_soundevent_guid() const {
  return _internal_has_soundevent_guid();
}
inline void CMsgSosSetSoundEventParams::clear_soundevent_guid() {
  _impl_.soundevent_guid_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CMsgSosSetSoundEventParams::_internal_soundevent_guid() const {
  return _impl_.soundevent_guid_;
}
inline int32_t CMsgSosSetSoundEventParams::soundevent_guid() const {
  // @@protoc_insertion_point(field_get:CMsgSosSetSoundEventParams.soundevent_guid)
  return _internal_soundevent_guid();
}
inline void CMsgSosSetSoundEventParams::_internal_set_soundevent_guid(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.soundevent_guid_ = value;
}
inline void CMsgSosSetSoundEventParams::set_soundevent_guid(int32_t value) {
  _internal_set_soundevent_guid(value);
  // @@protoc_insertion_point(field_set:CMsgSosSetSoundEventParams.soundevent_guid)
}

// optional bytes packed_params = 5;
inline bool CMsgSosSetSoundEventParams::_internal_has_packed_params() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSosSetSoundEventParams::has_packed_params() const {
  return _internal_has_packed_params();
}
inline void CMsgSosSetSoundEventParams::clear_packed_params() {
  _impl_.packed_params_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSosSetSoundEventParams::packed_params() const {
  // @@protoc_insertion_point(field_get:CMsgSosSetSoundEventParams.packed_params)
  return _internal_packed_params();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSosSetSoundEventParams::set_packed_params(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.packed_params_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSosSetSoundEventParams.packed_params)
}
inline std::string* CMsgSosSetSoundEventParams::mutable_packed_params() {
  std::string* _s = _internal_mutable_packed_params();
  // @@protoc_insertion_point(field_mutable:CMsgSosSetSoundEventParams.packed_params)
  return _s;
}
inline const std::string& CMsgSosSetSoundEventParams::_internal_packed_params() const {
  return _impl_.packed_params_.Get();
}
inline void CMsgSosSetSoundEventParams::_internal_set_packed_params(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.packed_params_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSosSetSoundEventParams::_internal_mutable_packed_params() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.packed_params_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSosSetSoundEventParams::release_packed_params() {
  // @@protoc_insertion_point(field_release:CMsgSosSetSoundEventParams.packed_params)
  if (!_internal_has_packed_params()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.packed_params_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.packed_params_.IsDefault()) {
    _impl_.packed_params_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSosSetSoundEventParams::set_allocated_packed_params(std::string* packed_params) {
  if (packed_params != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.packed_params_.SetAllocated(packed_params, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.packed_params_.IsDefault()) {
    _impl_.packed_params_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSosSetSoundEventParams.packed_params)
}

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

// CMsgSosSetLibraryStackFields

// optional fixed32 stack_hash = 1;
inline bool CMsgSosSetLibraryStackFields::_internal_has_stack_hash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSosSetLibraryStackFields::has_stack_hash() const {
  return _internal_has_stack_hash();
}
inline void CMsgSosSetLibraryStackFields::clear_stack_hash() {
  _impl_.stack_hash_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSosSetLibraryStackFields::_internal_stack_hash() const {
  return _impl_.stack_hash_;
}
inline uint32_t CMsgSosSetLibraryStackFields::stack_hash() const {
  // @@protoc_insertion_point(field_get:CMsgSosSetLibraryStackFields.stack_hash)
  return _internal_stack_hash();
}
inline void CMsgSosSetLibraryStackFields::_internal_set_stack_hash(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.stack_hash_ = value;
}
inline void CMsgSosSetLibraryStackFields::set_stack_hash(uint32_t value) {
  _internal_set_stack_hash(value);
  // @@protoc_insertion_point(field_set:CMsgSosSetLibraryStackFields.stack_hash)
}

// optional bytes packed_fields = 5;
inline bool CMsgSosSetLibraryStackFields::_internal_has_packed_fields() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSosSetLibraryStackFields::has_packed_fields() const {
  return _internal_has_packed_fields();
}
inline void CMsgSosSetLibraryStackFields::clear_packed_fields() {
  _impl_.packed_fields_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSosSetLibraryStackFields::packed_fields() const {
  // @@protoc_insertion_point(field_get:CMsgSosSetLibraryStackFields.packed_fields)
  return _internal_packed_fields();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSosSetLibraryStackFields::set_packed_fields(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.packed_fields_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSosSetLibraryStackFields.packed_fields)
}
inline std::string* CMsgSosSetLibraryStackFields::mutable_packed_fields() {
  std::string* _s = _internal_mutable_packed_fields();
  // @@protoc_insertion_point(field_mutable:CMsgSosSetLibraryStackFields.packed_fields)
  return _s;
}
inline const std::string& CMsgSosSetLibraryStackFields::_internal_packed_fields() const {
  return _impl_.packed_fields_.Get();
}
inline void CMsgSosSetLibraryStackFields::_internal_set_packed_fields(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.packed_fields_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSosSetLibraryStackFields::_internal_mutable_packed_fields() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.packed_fields_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSosSetLibraryStackFields::release_packed_fields() {
  // @@protoc_insertion_point(field_release:CMsgSosSetLibraryStackFields.packed_fields)
  if (!_internal_has_packed_fields()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.packed_fields_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.packed_fields_.IsDefault()) {
    _impl_.packed_fields_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSosSetLibraryStackFields::set_allocated_packed_fields(std::string* packed_fields) {
  if (packed_fields != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.packed_fields_.SetAllocated(packed_fields, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.packed_fields_.IsDefault()) {
    _impl_.packed_fields_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSosSetLibraryStackFields.packed_fields)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::EBaseGameEvents> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::EBaseGameEvents>() {
  return ::EBaseGameEvents_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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