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

#ifndef GOOGLE_PROTOBUF_INCLUDED_te_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_te_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_te_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_te_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_te_2eproto;
class CMsgEffectData;
struct CMsgEffectDataDefaultTypeInternal;
extern CMsgEffectDataDefaultTypeInternal _CMsgEffectData_default_instance_;
class CMsgTEArmorRicochet;
struct CMsgTEArmorRicochetDefaultTypeInternal;
extern CMsgTEArmorRicochetDefaultTypeInternal _CMsgTEArmorRicochet_default_instance_;
class CMsgTEBaseBeam;
struct CMsgTEBaseBeamDefaultTypeInternal;
extern CMsgTEBaseBeamDefaultTypeInternal _CMsgTEBaseBeam_default_instance_;
class CMsgTEBeamEntPoint;
struct CMsgTEBeamEntPointDefaultTypeInternal;
extern CMsgTEBeamEntPointDefaultTypeInternal _CMsgTEBeamEntPoint_default_instance_;
class CMsgTEBeamEnts;
struct CMsgTEBeamEntsDefaultTypeInternal;
extern CMsgTEBeamEntsDefaultTypeInternal _CMsgTEBeamEnts_default_instance_;
class CMsgTEBeamPoints;
struct CMsgTEBeamPointsDefaultTypeInternal;
extern CMsgTEBeamPointsDefaultTypeInternal _CMsgTEBeamPoints_default_instance_;
class CMsgTEBeamRing;
struct CMsgTEBeamRingDefaultTypeInternal;
extern CMsgTEBeamRingDefaultTypeInternal _CMsgTEBeamRing_default_instance_;
class CMsgTEBloodStream;
struct CMsgTEBloodStreamDefaultTypeInternal;
extern CMsgTEBloodStreamDefaultTypeInternal _CMsgTEBloodStream_default_instance_;
class CMsgTEBubbleTrail;
struct CMsgTEBubbleTrailDefaultTypeInternal;
extern CMsgTEBubbleTrailDefaultTypeInternal _CMsgTEBubbleTrail_default_instance_;
class CMsgTEBubbles;
struct CMsgTEBubblesDefaultTypeInternal;
extern CMsgTEBubblesDefaultTypeInternal _CMsgTEBubbles_default_instance_;
class CMsgTEDecal;
struct CMsgTEDecalDefaultTypeInternal;
extern CMsgTEDecalDefaultTypeInternal _CMsgTEDecal_default_instance_;
class CMsgTEDust;
struct CMsgTEDustDefaultTypeInternal;
extern CMsgTEDustDefaultTypeInternal _CMsgTEDust_default_instance_;
class CMsgTEEffectDispatch;
struct CMsgTEEffectDispatchDefaultTypeInternal;
extern CMsgTEEffectDispatchDefaultTypeInternal _CMsgTEEffectDispatch_default_instance_;
class CMsgTEEnergySplash;
struct CMsgTEEnergySplashDefaultTypeInternal;
extern CMsgTEEnergySplashDefaultTypeInternal _CMsgTEEnergySplash_default_instance_;
class CMsgTEExplosion;
struct CMsgTEExplosionDefaultTypeInternal;
extern CMsgTEExplosionDefaultTypeInternal _CMsgTEExplosion_default_instance_;
class CMsgTEFizz;
struct CMsgTEFizzDefaultTypeInternal;
extern CMsgTEFizzDefaultTypeInternal _CMsgTEFizz_default_instance_;
class CMsgTEGlowSprite;
struct CMsgTEGlowSpriteDefaultTypeInternal;
extern CMsgTEGlowSpriteDefaultTypeInternal _CMsgTEGlowSprite_default_instance_;
class CMsgTEImpact;
struct CMsgTEImpactDefaultTypeInternal;
extern CMsgTEImpactDefaultTypeInternal _CMsgTEImpact_default_instance_;
class CMsgTELargeFunnel;
struct CMsgTELargeFunnelDefaultTypeInternal;
extern CMsgTELargeFunnelDefaultTypeInternal _CMsgTELargeFunnel_default_instance_;
class CMsgTEMuzzleFlash;
struct CMsgTEMuzzleFlashDefaultTypeInternal;
extern CMsgTEMuzzleFlashDefaultTypeInternal _CMsgTEMuzzleFlash_default_instance_;
class CMsgTEPhysicsProp;
struct CMsgTEPhysicsPropDefaultTypeInternal;
extern CMsgTEPhysicsPropDefaultTypeInternal _CMsgTEPhysicsProp_default_instance_;
class CMsgTEShatterSurface;
struct CMsgTEShatterSurfaceDefaultTypeInternal;
extern CMsgTEShatterSurfaceDefaultTypeInternal _CMsgTEShatterSurface_default_instance_;
class CMsgTESmoke;
struct CMsgTESmokeDefaultTypeInternal;
extern CMsgTESmokeDefaultTypeInternal _CMsgTESmoke_default_instance_;
class CMsgTESparks;
struct CMsgTESparksDefaultTypeInternal;
extern CMsgTESparksDefaultTypeInternal _CMsgTESparks_default_instance_;
class CMsgTEWorldDecal;
struct CMsgTEWorldDecalDefaultTypeInternal;
extern CMsgTEWorldDecalDefaultTypeInternal _CMsgTEWorldDecal_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::CMsgEffectData* Arena::CreateMaybeMessage<::CMsgEffectData>(Arena*);
template<> ::CMsgTEArmorRicochet* Arena::CreateMaybeMessage<::CMsgTEArmorRicochet>(Arena*);
template<> ::CMsgTEBaseBeam* Arena::CreateMaybeMessage<::CMsgTEBaseBeam>(Arena*);
template<> ::CMsgTEBeamEntPoint* Arena::CreateMaybeMessage<::CMsgTEBeamEntPoint>(Arena*);
template<> ::CMsgTEBeamEnts* Arena::CreateMaybeMessage<::CMsgTEBeamEnts>(Arena*);
template<> ::CMsgTEBeamPoints* Arena::CreateMaybeMessage<::CMsgTEBeamPoints>(Arena*);
template<> ::CMsgTEBeamRing* Arena::CreateMaybeMessage<::CMsgTEBeamRing>(Arena*);
template<> ::CMsgTEBloodStream* Arena::CreateMaybeMessage<::CMsgTEBloodStream>(Arena*);
template<> ::CMsgTEBubbleTrail* Arena::CreateMaybeMessage<::CMsgTEBubbleTrail>(Arena*);
template<> ::CMsgTEBubbles* Arena::CreateMaybeMessage<::CMsgTEBubbles>(Arena*);
template<> ::CMsgTEDecal* Arena::CreateMaybeMessage<::CMsgTEDecal>(Arena*);
template<> ::CMsgTEDust* Arena::CreateMaybeMessage<::CMsgTEDust>(Arena*);
template<> ::CMsgTEEffectDispatch* Arena::CreateMaybeMessage<::CMsgTEEffectDispatch>(Arena*);
template<> ::CMsgTEEnergySplash* Arena::CreateMaybeMessage<::CMsgTEEnergySplash>(Arena*);
template<> ::CMsgTEExplosion* Arena::CreateMaybeMessage<::CMsgTEExplosion>(Arena*);
template<> ::CMsgTEFizz* Arena::CreateMaybeMessage<::CMsgTEFizz>(Arena*);
template<> ::CMsgTEGlowSprite* Arena::CreateMaybeMessage<::CMsgTEGlowSprite>(Arena*);
template<> ::CMsgTEImpact* Arena::CreateMaybeMessage<::CMsgTEImpact>(Arena*);
template<> ::CMsgTELargeFunnel* Arena::CreateMaybeMessage<::CMsgTELargeFunnel>(Arena*);
template<> ::CMsgTEMuzzleFlash* Arena::CreateMaybeMessage<::CMsgTEMuzzleFlash>(Arena*);
template<> ::CMsgTEPhysicsProp* Arena::CreateMaybeMessage<::CMsgTEPhysicsProp>(Arena*);
template<> ::CMsgTEShatterSurface* Arena::CreateMaybeMessage<::CMsgTEShatterSurface>(Arena*);
template<> ::CMsgTESmoke* Arena::CreateMaybeMessage<::CMsgTESmoke>(Arena*);
template<> ::CMsgTESparks* Arena::CreateMaybeMessage<::CMsgTESparks>(Arena*);
template<> ::CMsgTEWorldDecal* Arena::CreateMaybeMessage<::CMsgTEWorldDecal>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum ETEProtobufIds : int {
  TE_EffectDispatchId = 400,
  TE_ArmorRicochetId = 401,
  TE_BeamEntPointId = 402,
  TE_BeamEntsId = 403,
  TE_BeamPointsId = 404,
  TE_BeamRingId = 405,
  TE_BubblesId = 408,
  TE_BubbleTrailId = 409,
  TE_DecalId = 410,
  TE_WorldDecalId = 411,
  TE_EnergySplashId = 412,
  TE_FizzId = 413,
  TE_ShatterSurfaceId = 414,
  TE_GlowSpriteId = 415,
  TE_ImpactId = 416,
  TE_MuzzleFlashId = 417,
  TE_BloodStreamId = 418,
  TE_ExplosionId = 419,
  TE_DustId = 420,
  TE_LargeFunnelId = 421,
  TE_SparksId = 422,
  TE_PhysicsPropId = 423,
  TE_SmokeId = 426
};
bool ETEProtobufIds_IsValid(int value);
constexpr ETEProtobufIds ETEProtobufIds_MIN = TE_EffectDispatchId;
constexpr ETEProtobufIds ETEProtobufIds_MAX = TE_SmokeId;
constexpr int ETEProtobufIds_ARRAYSIZE = ETEProtobufIds_MAX + 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

  // optional .CMsgVector dir = 2;
  bool has_dir() const;
  private:
  bool _internal_has_dir() const;
  public:
  void clear_dir();
  const ::CMsgVector& dir() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_dir();
  ::CMsgVector* mutable_dir();
  void set_allocated_dir(::CMsgVector* dir);
  private:
  const ::CMsgVector& _internal_dir() const;
  ::CMsgVector* _internal_mutable_dir();
  public:
  void unsafe_arena_set_allocated_dir(
      ::CMsgVector* dir);
  ::CMsgVector* unsafe_arena_release_dir();

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

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEBaseBeam";
  }
  protected:
  explicit CMsgTEBaseBeam(::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 {
    kModelindexFieldNumber = 1,
    kHaloindexFieldNumber = 2,
    kStartframeFieldNumber = 3,
    kFramerateFieldNumber = 4,
    kLifeFieldNumber = 5,
    kWidthFieldNumber = 6,
    kEndwidthFieldNumber = 7,
    kFadelengthFieldNumber = 8,
    kAmplitudeFieldNumber = 9,
    kColorFieldNumber = 10,
    kSpeedFieldNumber = 11,
    kFlagsFieldNumber = 12,
  };
  // optional fixed64 modelindex = 1;
  bool has_modelindex() const;
  private:
  bool _internal_has_modelindex() const;
  public:
  void clear_modelindex();
  uint64_t modelindex() const;
  void set_modelindex(uint64_t value);
  private:
  uint64_t _internal_modelindex() const;
  void _internal_set_modelindex(uint64_t value);
  public:

  // optional fixed64 haloindex = 2;
  bool has_haloindex() const;
  private:
  bool _internal_has_haloindex() const;
  public:
  void clear_haloindex();
  uint64_t haloindex() const;
  void set_haloindex(uint64_t value);
  private:
  uint64_t _internal_haloindex() const;
  void _internal_set_haloindex(uint64_t value);
  public:

  // optional uint32 startframe = 3;
  bool has_startframe() const;
  private:
  bool _internal_has_startframe() const;
  public:
  void clear_startframe();
  uint32_t startframe() const;
  void set_startframe(uint32_t value);
  private:
  uint32_t _internal_startframe() const;
  void _internal_set_startframe(uint32_t value);
  public:

  // optional uint32 framerate = 4;
  bool has_framerate() const;
  private:
  bool _internal_has_framerate() const;
  public:
  void clear_framerate();
  uint32_t framerate() const;
  void set_framerate(uint32_t value);
  private:
  uint32_t _internal_framerate() const;
  void _internal_set_framerate(uint32_t value);
  public:

  // optional float life = 5;
  bool has_life() const;
  private:
  bool _internal_has_life() const;
  public:
  void clear_life();
  float life() const;
  void set_life(float value);
  private:
  float _internal_life() const;
  void _internal_set_life(float value);
  public:

  // optional float width = 6;
  bool has_width() const;
  private:
  bool _internal_has_width() const;
  public:
  void clear_width();
  float width() const;
  void set_width(float value);
  private:
  float _internal_width() const;
  void _internal_set_width(float value);
  public:

  // optional float endwidth = 7;
  bool has_endwidth() const;
  private:
  bool _internal_has_endwidth() const;
  public:
  void clear_endwidth();
  float endwidth() const;
  void set_endwidth(float value);
  private:
  float _internal_endwidth() const;
  void _internal_set_endwidth(float value);
  public:

  // optional uint32 fadelength = 8;
  bool has_fadelength() const;
  private:
  bool _internal_has_fadelength() const;
  public:
  void clear_fadelength();
  uint32_t fadelength() const;
  void set_fadelength(uint32_t value);
  private:
  uint32_t _internal_fadelength() const;
  void _internal_set_fadelength(uint32_t value);
  public:

  // optional float amplitude = 9;
  bool has_amplitude() const;
  private:
  bool _internal_has_amplitude() const;
  public:
  void clear_amplitude();
  float amplitude() const;
  void set_amplitude(float value);
  private:
  float _internal_amplitude() const;
  void _internal_set_amplitude(float value);
  public:

  // optional fixed32 color = 10;
  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 uint32 speed = 11;
  bool has_speed() const;
  private:
  bool _internal_has_speed() const;
  public:
  void clear_speed();
  uint32_t speed() const;
  void set_speed(uint32_t value);
  private:
  uint32_t _internal_speed() const;
  void _internal_set_speed(uint32_t value);
  public:

  // optional uint32 flags = 12;
  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:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint64_t modelindex_;
    uint64_t haloindex_;
    uint32_t startframe_;
    uint32_t framerate_;
    float life_;
    float width_;
    float endwidth_;
    uint32_t fadelength_;
    float amplitude_;
    uint32_t color_;
    uint32_t speed_;
    uint32_t flags_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEBeamEntPoint";
  }
  protected:
  explicit CMsgTEBeamEntPoint(::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 {
    kBaseFieldNumber = 1,
    kStartFieldNumber = 4,
    kEndFieldNumber = 5,
    kStartentityFieldNumber = 2,
    kEndentityFieldNumber = 3,
  };
  // optional .CMsgTEBaseBeam base = 1;
  bool has_base() const;
  private:
  bool _internal_has_base() const;
  public:
  void clear_base();
  const ::CMsgTEBaseBeam& base() const;
  PROTOBUF_NODISCARD ::CMsgTEBaseBeam* release_base();
  ::CMsgTEBaseBeam* mutable_base();
  void set_allocated_base(::CMsgTEBaseBeam* base);
  private:
  const ::CMsgTEBaseBeam& _internal_base() const;
  ::CMsgTEBaseBeam* _internal_mutable_base();
  public:
  void unsafe_arena_set_allocated_base(
      ::CMsgTEBaseBeam* base);
  ::CMsgTEBaseBeam* unsafe_arena_release_base();

  // optional .CMsgVector start = 4;
  bool has_start() const;
  private:
  bool _internal_has_start() const;
  public:
  void clear_start();
  const ::CMsgVector& start() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_start();
  ::CMsgVector* mutable_start();
  void set_allocated_start(::CMsgVector* start);
  private:
  const ::CMsgVector& _internal_start() const;
  ::CMsgVector* _internal_mutable_start();
  public:
  void unsafe_arena_set_allocated_start(
      ::CMsgVector* start);
  ::CMsgVector* unsafe_arena_release_start();

  // optional .CMsgVector end = 5;
  bool has_end() const;
  private:
  bool _internal_has_end() const;
  public:
  void clear_end();
  const ::CMsgVector& end() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_end();
  ::CMsgVector* mutable_end();
  void set_allocated_end(::CMsgVector* end);
  private:
  const ::CMsgVector& _internal_end() const;
  ::CMsgVector* _internal_mutable_end();
  public:
  void unsafe_arena_set_allocated_end(
      ::CMsgVector* end);
  ::CMsgVector* unsafe_arena_release_end();

  // optional uint32 startentity = 2;
  bool has_startentity() const;
  private:
  bool _internal_has_startentity() const;
  public:
  void clear_startentity();
  uint32_t startentity() const;
  void set_startentity(uint32_t value);
  private:
  uint32_t _internal_startentity() const;
  void _internal_set_startentity(uint32_t value);
  public:

  // optional uint32 endentity = 3;
  bool has_endentity() const;
  private:
  bool _internal_has_endentity() const;
  public:
  void clear_endentity();
  uint32_t endentity() const;
  void set_endentity(uint32_t value);
  private:
  uint32_t _internal_endentity() const;
  void _internal_set_endentity(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEBeamEntPoint)
 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_;
    ::CMsgTEBaseBeam* base_;
    ::CMsgVector* start_;
    ::CMsgVector* end_;
    uint32_t startentity_;
    uint32_t endentity_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEBeamEnts";
  }
  protected:
  explicit CMsgTEBeamEnts(::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 {
    kBaseFieldNumber = 1,
    kStartentityFieldNumber = 2,
    kEndentityFieldNumber = 3,
  };
  // optional .CMsgTEBaseBeam base = 1;
  bool has_base() const;
  private:
  bool _internal_has_base() const;
  public:
  void clear_base();
  const ::CMsgTEBaseBeam& base() const;
  PROTOBUF_NODISCARD ::CMsgTEBaseBeam* release_base();
  ::CMsgTEBaseBeam* mutable_base();
  void set_allocated_base(::CMsgTEBaseBeam* base);
  private:
  const ::CMsgTEBaseBeam& _internal_base() const;
  ::CMsgTEBaseBeam* _internal_mutable_base();
  public:
  void unsafe_arena_set_allocated_base(
      ::CMsgTEBaseBeam* base);
  ::CMsgTEBaseBeam* unsafe_arena_release_base();

  // optional uint32 startentity = 2;
  bool has_startentity() const;
  private:
  bool _internal_has_startentity() const;
  public:
  void clear_startentity();
  uint32_t startentity() const;
  void set_startentity(uint32_t value);
  private:
  uint32_t _internal_startentity() const;
  void _internal_set_startentity(uint32_t value);
  public:

  // optional uint32 endentity = 3;
  bool has_endentity() const;
  private:
  bool _internal_has_endentity() const;
  public:
  void clear_endentity();
  uint32_t endentity() const;
  void set_endentity(uint32_t value);
  private:
  uint32_t _internal_endentity() const;
  void _internal_set_endentity(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEBeamEnts)
 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_;
    ::CMsgTEBaseBeam* base_;
    uint32_t startentity_;
    uint32_t endentity_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEBeamPoints";
  }
  protected:
  explicit CMsgTEBeamPoints(::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 {
    kBaseFieldNumber = 1,
    kStartFieldNumber = 2,
    kEndFieldNumber = 3,
  };
  // optional .CMsgTEBaseBeam base = 1;
  bool has_base() const;
  private:
  bool _internal_has_base() const;
  public:
  void clear_base();
  const ::CMsgTEBaseBeam& base() const;
  PROTOBUF_NODISCARD ::CMsgTEBaseBeam* release_base();
  ::CMsgTEBaseBeam* mutable_base();
  void set_allocated_base(::CMsgTEBaseBeam* base);
  private:
  const ::CMsgTEBaseBeam& _internal_base() const;
  ::CMsgTEBaseBeam* _internal_mutable_base();
  public:
  void unsafe_arena_set_allocated_base(
      ::CMsgTEBaseBeam* base);
  ::CMsgTEBaseBeam* unsafe_arena_release_base();

  // optional .CMsgVector start = 2;
  bool has_start() const;
  private:
  bool _internal_has_start() const;
  public:
  void clear_start();
  const ::CMsgVector& start() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_start();
  ::CMsgVector* mutable_start();
  void set_allocated_start(::CMsgVector* start);
  private:
  const ::CMsgVector& _internal_start() const;
  ::CMsgVector* _internal_mutable_start();
  public:
  void unsafe_arena_set_allocated_start(
      ::CMsgVector* start);
  ::CMsgVector* unsafe_arena_release_start();

  // optional .CMsgVector end = 3;
  bool has_end() const;
  private:
  bool _internal_has_end() const;
  public:
  void clear_end();
  const ::CMsgVector& end() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_end();
  ::CMsgVector* mutable_end();
  void set_allocated_end(::CMsgVector* end);
  private:
  const ::CMsgVector& _internal_end() const;
  ::CMsgVector* _internal_mutable_end();
  public:
  void unsafe_arena_set_allocated_end(
      ::CMsgVector* end);
  ::CMsgVector* unsafe_arena_release_end();

  // @@protoc_insertion_point(class_scope:CMsgTEBeamPoints)
 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_;
    ::CMsgTEBaseBeam* base_;
    ::CMsgVector* start_;
    ::CMsgVector* end_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEBeamRing";
  }
  protected:
  explicit CMsgTEBeamRing(::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 {
    kBaseFieldNumber = 1,
    kStartentityFieldNumber = 2,
    kEndentityFieldNumber = 3,
  };
  // optional .CMsgTEBaseBeam base = 1;
  bool has_base() const;
  private:
  bool _internal_has_base() const;
  public:
  void clear_base();
  const ::CMsgTEBaseBeam& base() const;
  PROTOBUF_NODISCARD ::CMsgTEBaseBeam* release_base();
  ::CMsgTEBaseBeam* mutable_base();
  void set_allocated_base(::CMsgTEBaseBeam* base);
  private:
  const ::CMsgTEBaseBeam& _internal_base() const;
  ::CMsgTEBaseBeam* _internal_mutable_base();
  public:
  void unsafe_arena_set_allocated_base(
      ::CMsgTEBaseBeam* base);
  ::CMsgTEBaseBeam* unsafe_arena_release_base();

  // optional uint32 startentity = 2;
  bool has_startentity() const;
  private:
  bool _internal_has_startentity() const;
  public:
  void clear_startentity();
  uint32_t startentity() const;
  void set_startentity(uint32_t value);
  private:
  uint32_t _internal_startentity() const;
  void _internal_set_startentity(uint32_t value);
  public:

  // optional uint32 endentity = 3;
  bool has_endentity() const;
  private:
  bool _internal_has_endentity() const;
  public:
  void clear_endentity();
  uint32_t endentity() const;
  void set_endentity(uint32_t value);
  private:
  uint32_t _internal_endentity() const;
  void _internal_set_endentity(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEBeamRing)
 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_;
    ::CMsgTEBaseBeam* base_;
    uint32_t startentity_;
    uint32_t endentity_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEBubbles";
  }
  protected:
  explicit CMsgTEBubbles(::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 {
    kMinsFieldNumber = 1,
    kMaxsFieldNumber = 2,
    kHeightFieldNumber = 3,
    kCountFieldNumber = 4,
    kSpeedFieldNumber = 5,
  };
  // optional .CMsgVector mins = 1;
  bool has_mins() const;
  private:
  bool _internal_has_mins() const;
  public:
  void clear_mins();
  const ::CMsgVector& mins() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_mins();
  ::CMsgVector* mutable_mins();
  void set_allocated_mins(::CMsgVector* mins);
  private:
  const ::CMsgVector& _internal_mins() const;
  ::CMsgVector* _internal_mutable_mins();
  public:
  void unsafe_arena_set_allocated_mins(
      ::CMsgVector* mins);
  ::CMsgVector* unsafe_arena_release_mins();

  // optional .CMsgVector maxs = 2;
  bool has_maxs() const;
  private:
  bool _internal_has_maxs() const;
  public:
  void clear_maxs();
  const ::CMsgVector& maxs() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_maxs();
  ::CMsgVector* mutable_maxs();
  void set_allocated_maxs(::CMsgVector* maxs);
  private:
  const ::CMsgVector& _internal_maxs() const;
  ::CMsgVector* _internal_mutable_maxs();
  public:
  void unsafe_arena_set_allocated_maxs(
      ::CMsgVector* maxs);
  ::CMsgVector* unsafe_arena_release_maxs();

  // optional float height = 3;
  bool has_height() const;
  private:
  bool _internal_has_height() const;
  public:
  void clear_height();
  float height() const;
  void set_height(float value);
  private:
  float _internal_height() const;
  void _internal_set_height(float value);
  public:

  // optional uint32 count = 4;
  bool has_count() const;
  private:
  bool _internal_has_count() const;
  public:
  void clear_count();
  uint32_t count() const;
  void set_count(uint32_t value);
  private:
  uint32_t _internal_count() const;
  void _internal_set_count(uint32_t value);
  public:

  // optional float speed = 5;
  bool has_speed() const;
  private:
  bool _internal_has_speed() const;
  public:
  void clear_speed();
  float speed() const;
  void set_speed(float value);
  private:
  float _internal_speed() const;
  void _internal_set_speed(float value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEBubbles)
 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* mins_;
    ::CMsgVector* maxs_;
    float height_;
    uint32_t count_;
    float speed_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEBubbleTrail";
  }
  protected:
  explicit CMsgTEBubbleTrail(::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 {
    kMinsFieldNumber = 1,
    kMaxsFieldNumber = 2,
    kWaterzFieldNumber = 3,
    kCountFieldNumber = 4,
    kSpeedFieldNumber = 5,
  };
  // optional .CMsgVector mins = 1;
  bool has_mins() const;
  private:
  bool _internal_has_mins() const;
  public:
  void clear_mins();
  const ::CMsgVector& mins() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_mins();
  ::CMsgVector* mutable_mins();
  void set_allocated_mins(::CMsgVector* mins);
  private:
  const ::CMsgVector& _internal_mins() const;
  ::CMsgVector* _internal_mutable_mins();
  public:
  void unsafe_arena_set_allocated_mins(
      ::CMsgVector* mins);
  ::CMsgVector* unsafe_arena_release_mins();

  // optional .CMsgVector maxs = 2;
  bool has_maxs() const;
  private:
  bool _internal_has_maxs() const;
  public:
  void clear_maxs();
  const ::CMsgVector& maxs() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_maxs();
  ::CMsgVector* mutable_maxs();
  void set_allocated_maxs(::CMsgVector* maxs);
  private:
  const ::CMsgVector& _internal_maxs() const;
  ::CMsgVector* _internal_mutable_maxs();
  public:
  void unsafe_arena_set_allocated_maxs(
      ::CMsgVector* maxs);
  ::CMsgVector* unsafe_arena_release_maxs();

  // optional float waterz = 3;
  bool has_waterz() const;
  private:
  bool _internal_has_waterz() const;
  public:
  void clear_waterz();
  float waterz() const;
  void set_waterz(float value);
  private:
  float _internal_waterz() const;
  void _internal_set_waterz(float value);
  public:

  // optional uint32 count = 4;
  bool has_count() const;
  private:
  bool _internal_has_count() const;
  public:
  void clear_count();
  uint32_t count() const;
  void set_count(uint32_t value);
  private:
  uint32_t _internal_count() const;
  void _internal_set_count(uint32_t value);
  public:

  // optional float speed = 5;
  bool has_speed() const;
  private:
  bool _internal_has_speed() const;
  public:
  void clear_speed();
  float speed() const;
  void set_speed(float value);
  private:
  float _internal_speed() const;
  void _internal_set_speed(float value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEBubbleTrail)
 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* mins_;
    ::CMsgVector* maxs_;
    float waterz_;
    uint32_t count_;
    float speed_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEDecal";
  }
  protected:
  explicit CMsgTEDecal(::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 {
    kOriginFieldNumber = 1,
    kStartFieldNumber = 2,
    kHitboxFieldNumber = 4,
    kIndexFieldNumber = 5,
    kEntityFieldNumber = 3,
  };
  // optional .CMsgVector origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

  // optional .CMsgVector start = 2;
  bool has_start() const;
  private:
  bool _internal_has_start() const;
  public:
  void clear_start();
  const ::CMsgVector& start() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_start();
  ::CMsgVector* mutable_start();
  void set_allocated_start(::CMsgVector* start);
  private:
  const ::CMsgVector& _internal_start() const;
  ::CMsgVector* _internal_mutable_start();
  public:
  void unsafe_arena_set_allocated_start(
      ::CMsgVector* start);
  ::CMsgVector* unsafe_arena_release_start();

  // optional uint32 hitbox = 4;
  bool has_hitbox() const;
  private:
  bool _internal_has_hitbox() const;
  public:
  void clear_hitbox();
  uint32_t hitbox() const;
  void set_hitbox(uint32_t value);
  private:
  uint32_t _internal_hitbox() const;
  void _internal_set_hitbox(uint32_t value);
  public:

  // optional uint32 index = 5;
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  uint32_t index() const;
  void set_index(uint32_t value);
  private:
  uint32_t _internal_index() const;
  void _internal_set_index(uint32_t value);
  public:

  // optional int32 entity = 3 [default = -1];
  bool has_entity() const;
  private:
  bool _internal_has_entity() const;
  public:
  void clear_entity();
  int32_t entity() const;
  void set_entity(int32_t value);
  private:
  int32_t _internal_entity() const;
  void _internal_set_entity(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEDecal)
 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* origin_;
    ::CMsgVector* start_;
    uint32_t hitbox_;
    uint32_t index_;
    int32_t entity_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgEffectData";
  }
  protected:
  explicit CMsgEffectData(::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 {
    kOriginFieldNumber = 1,
    kStartFieldNumber = 2,
    kNormalFieldNumber = 3,
    kAnglesFieldNumber = 4,
    kScaleFieldNumber = 7,
    kMagnitudeFieldNumber = 8,
    kRadiusFieldNumber = 9,
    kSurfacepropFieldNumber = 10,
    kEffectindexFieldNumber = 11,
    kDamagetypeFieldNumber = 12,
    kMaterialFieldNumber = 13,
    kHitboxFieldNumber = 14,
    kColorFieldNumber = 15,
    kFlagsFieldNumber = 16,
    kAttachmentindexFieldNumber = 17,
    kEffectnameFieldNumber = 18,
    kAttachmentnameFieldNumber = 19,
    kEntityFieldNumber = 5,
    kOtherentityFieldNumber = 6,
  };
  // optional .CMsgVector origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

  // optional .CMsgVector start = 2;
  bool has_start() const;
  private:
  bool _internal_has_start() const;
  public:
  void clear_start();
  const ::CMsgVector& start() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_start();
  ::CMsgVector* mutable_start();
  void set_allocated_start(::CMsgVector* start);
  private:
  const ::CMsgVector& _internal_start() const;
  ::CMsgVector* _internal_mutable_start();
  public:
  void unsafe_arena_set_allocated_start(
      ::CMsgVector* start);
  ::CMsgVector* unsafe_arena_release_start();

  // optional .CMsgVector normal = 3;
  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 .CMsgQAngle angles = 4;
  bool has_angles() const;
  private:
  bool _internal_has_angles() const;
  public:
  void clear_angles();
  const ::CMsgQAngle& angles() const;
  PROTOBUF_NODISCARD ::CMsgQAngle* release_angles();
  ::CMsgQAngle* mutable_angles();
  void set_allocated_angles(::CMsgQAngle* angles);
  private:
  const ::CMsgQAngle& _internal_angles() const;
  ::CMsgQAngle* _internal_mutable_angles();
  public:
  void unsafe_arena_set_allocated_angles(
      ::CMsgQAngle* angles);
  ::CMsgQAngle* unsafe_arena_release_angles();

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

  // optional float magnitude = 8;
  bool has_magnitude() const;
  private:
  bool _internal_has_magnitude() const;
  public:
  void clear_magnitude();
  float magnitude() const;
  void set_magnitude(float value);
  private:
  float _internal_magnitude() const;
  void _internal_set_magnitude(float value);
  public:

  // optional float radius = 9;
  bool has_radius() const;
  private:
  bool _internal_has_radius() const;
  public:
  void clear_radius();
  float radius() const;
  void set_radius(float value);
  private:
  float _internal_radius() const;
  void _internal_set_radius(float value);
  public:

  // optional fixed32 surfaceprop = 10;
  bool has_surfaceprop() const;
  private:
  bool _internal_has_surfaceprop() const;
  public:
  void clear_surfaceprop();
  uint32_t surfaceprop() const;
  void set_surfaceprop(uint32_t value);
  private:
  uint32_t _internal_surfaceprop() const;
  void _internal_set_surfaceprop(uint32_t value);
  public:

  // optional fixed64 effectindex = 11;
  bool has_effectindex() const;
  private:
  bool _internal_has_effectindex() const;
  public:
  void clear_effectindex();
  uint64_t effectindex() const;
  void set_effectindex(uint64_t value);
  private:
  uint64_t _internal_effectindex() const;
  void _internal_set_effectindex(uint64_t value);
  public:

  // optional uint32 damagetype = 12;
  bool has_damagetype() const;
  private:
  bool _internal_has_damagetype() const;
  public:
  void clear_damagetype();
  uint32_t damagetype() const;
  void set_damagetype(uint32_t value);
  private:
  uint32_t _internal_damagetype() const;
  void _internal_set_damagetype(uint32_t value);
  public:

  // optional uint32 material = 13;
  bool has_material() const;
  private:
  bool _internal_has_material() const;
  public:
  void clear_material();
  uint32_t material() const;
  void set_material(uint32_t value);
  private:
  uint32_t _internal_material() const;
  void _internal_set_material(uint32_t value);
  public:

  // optional uint32 hitbox = 14;
  bool has_hitbox() const;
  private:
  bool _internal_has_hitbox() const;
  public:
  void clear_hitbox();
  uint32_t hitbox() const;
  void set_hitbox(uint32_t value);
  private:
  uint32_t _internal_hitbox() const;
  void _internal_set_hitbox(uint32_t value);
  public:

  // optional uint32 color = 15;
  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 uint32 flags = 16;
  bool has_flags() const;
  private:
  bool _internal_has_flags() const;
  public:
  void clear_flags();
  uint32_t flags() const;
  void set_flags(uint32_t value);
  private:
  uint32_t _internal_flags() const;
  void _internal_set_flags(uint32_t value);
  public:

  // optional int32 attachmentindex = 17;
  bool has_attachmentindex() const;
  private:
  bool _internal_has_attachmentindex() const;
  public:
  void clear_attachmentindex();
  int32_t attachmentindex() const;
  void set_attachmentindex(int32_t value);
  private:
  int32_t _internal_attachmentindex() const;
  void _internal_set_attachmentindex(int32_t value);
  public:

  // optional uint32 effectname = 18;
  bool has_effectname() const;
  private:
  bool _internal_has_effectname() const;
  public:
  void clear_effectname();
  uint32_t effectname() const;
  void set_effectname(uint32_t value);
  private:
  uint32_t _internal_effectname() const;
  void _internal_set_effectname(uint32_t value);
  public:

  // optional uint32 attachmentname = 19;
  bool has_attachmentname() const;
  private:
  bool _internal_has_attachmentname() const;
  public:
  void clear_attachmentname();
  uint32_t attachmentname() const;
  void set_attachmentname(uint32_t value);
  private:
  uint32_t _internal_attachmentname() const;
  void _internal_set_attachmentname(uint32_t value);
  public:

  // optional fixed32 entity = 5 [default = 16777215];
  bool has_entity() const;
  private:
  bool _internal_has_entity() const;
  public:
  void clear_entity();
  uint32_t entity() const;
  void set_entity(uint32_t value);
  private:
  uint32_t _internal_entity() const;
  void _internal_set_entity(uint32_t value);
  public:

  // optional fixed32 otherentity = 6 [default = 16777215];
  bool has_otherentity() const;
  private:
  bool _internal_has_otherentity() const;
  public:
  void clear_otherentity();
  uint32_t otherentity() const;
  void set_otherentity(uint32_t value);
  private:
  uint32_t _internal_otherentity() const;
  void _internal_set_otherentity(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgEffectData)
 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* origin_;
    ::CMsgVector* start_;
    ::CMsgVector* normal_;
    ::CMsgQAngle* angles_;
    float scale_;
    float magnitude_;
    float radius_;
    uint32_t surfaceprop_;
    uint64_t effectindex_;
    uint32_t damagetype_;
    uint32_t material_;
    uint32_t hitbox_;
    uint32_t color_;
    uint32_t flags_;
    int32_t attachmentindex_;
    uint32_t effectname_;
    uint32_t attachmentname_;
    uint32_t entity_;
    uint32_t otherentity_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEEffectDispatch";
  }
  protected:
  explicit CMsgTEEffectDispatch(::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 {
    kEffectdataFieldNumber = 1,
  };
  // optional .CMsgEffectData effectdata = 1;
  bool has_effectdata() const;
  private:
  bool _internal_has_effectdata() const;
  public:
  void clear_effectdata();
  const ::CMsgEffectData& effectdata() const;
  PROTOBUF_NODISCARD ::CMsgEffectData* release_effectdata();
  ::CMsgEffectData* mutable_effectdata();
  void set_allocated_effectdata(::CMsgEffectData* effectdata);
  private:
  const ::CMsgEffectData& _internal_effectdata() const;
  ::CMsgEffectData* _internal_mutable_effectdata();
  public:
  void unsafe_arena_set_allocated_effectdata(
      ::CMsgEffectData* effectdata);
  ::CMsgEffectData* unsafe_arena_release_effectdata();

  // @@protoc_insertion_point(class_scope:CMsgTEEffectDispatch)
 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_;
    ::CMsgEffectData* effectdata_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

  // optional .CMsgVector dir = 2;
  bool has_dir() const;
  private:
  bool _internal_has_dir() const;
  public:
  void clear_dir();
  const ::CMsgVector& dir() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_dir();
  ::CMsgVector* mutable_dir();
  void set_allocated_dir(::CMsgVector* dir);
  private:
  const ::CMsgVector& _internal_dir() const;
  ::CMsgVector* _internal_mutable_dir();
  public:
  void unsafe_arena_set_allocated_dir(
      ::CMsgVector* dir);
  ::CMsgVector* unsafe_arena_release_dir();

  // optional bool explosive = 3;
  bool has_explosive() const;
  private:
  bool _internal_has_explosive() const;
  public:
  void clear_explosive();
  bool explosive() const;
  void set_explosive(bool value);
  private:
  bool _internal_explosive() const;
  void _internal_set_explosive(bool value);
  public:

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

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEFizz";
  }
  protected:
  explicit CMsgTEFizz(::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 {
    kDensityFieldNumber = 2,
    kCurrentFieldNumber = 3,
    kEntityFieldNumber = 1,
  };
  // optional uint32 density = 2;
  bool has_density() const;
  private:
  bool _internal_has_density() const;
  public:
  void clear_density();
  uint32_t density() const;
  void set_density(uint32_t value);
  private:
  uint32_t _internal_density() const;
  void _internal_set_density(uint32_t value);
  public:

  // optional int32 current = 3;
  bool has_current() const;
  private:
  bool _internal_has_current() const;
  public:
  void clear_current();
  int32_t current() const;
  void set_current(int32_t value);
  private:
  int32_t _internal_current() const;
  void _internal_set_current(int32_t value);
  public:

  // optional int32 entity = 1 [default = -1];
  bool has_entity() const;
  private:
  bool _internal_has_entity() const;
  public:
  void clear_entity();
  int32_t entity() const;
  void set_entity(int32_t value);
  private:
  int32_t _internal_entity() const;
  void _internal_set_entity(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEFizz)
 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 density_;
    int32_t current_;
    int32_t entity_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEShatterSurface";
  }
  protected:
  explicit CMsgTEShatterSurface(::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 {
    kOriginFieldNumber = 1,
    kAnglesFieldNumber = 2,
    kForceFieldNumber = 3,
    kForceposFieldNumber = 4,
    kWidthFieldNumber = 5,
    kHeightFieldNumber = 6,
    kShardsizeFieldNumber = 7,
    kSurfacetypeFieldNumber = 8,
    kFrontcolorFieldNumber = 9,
    kBackcolorFieldNumber = 10,
  };
  // optional .CMsgVector origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

  // optional .CMsgQAngle angles = 2;
  bool has_angles() const;
  private:
  bool _internal_has_angles() const;
  public:
  void clear_angles();
  const ::CMsgQAngle& angles() const;
  PROTOBUF_NODISCARD ::CMsgQAngle* release_angles();
  ::CMsgQAngle* mutable_angles();
  void set_allocated_angles(::CMsgQAngle* angles);
  private:
  const ::CMsgQAngle& _internal_angles() const;
  ::CMsgQAngle* _internal_mutable_angles();
  public:
  void unsafe_arena_set_allocated_angles(
      ::CMsgQAngle* angles);
  ::CMsgQAngle* unsafe_arena_release_angles();

  // optional .CMsgVector force = 3;
  bool has_force() const;
  private:
  bool _internal_has_force() const;
  public:
  void clear_force();
  const ::CMsgVector& force() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_force();
  ::CMsgVector* mutable_force();
  void set_allocated_force(::CMsgVector* force);
  private:
  const ::CMsgVector& _internal_force() const;
  ::CMsgVector* _internal_mutable_force();
  public:
  void unsafe_arena_set_allocated_force(
      ::CMsgVector* force);
  ::CMsgVector* unsafe_arena_release_force();

  // optional .CMsgVector forcepos = 4;
  bool has_forcepos() const;
  private:
  bool _internal_has_forcepos() const;
  public:
  void clear_forcepos();
  const ::CMsgVector& forcepos() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_forcepos();
  ::CMsgVector* mutable_forcepos();
  void set_allocated_forcepos(::CMsgVector* forcepos);
  private:
  const ::CMsgVector& _internal_forcepos() const;
  ::CMsgVector* _internal_mutable_forcepos();
  public:
  void unsafe_arena_set_allocated_forcepos(
      ::CMsgVector* forcepos);
  ::CMsgVector* unsafe_arena_release_forcepos();

  // optional float width = 5;
  bool has_width() const;
  private:
  bool _internal_has_width() const;
  public:
  void clear_width();
  float width() const;
  void set_width(float value);
  private:
  float _internal_width() const;
  void _internal_set_width(float value);
  public:

  // optional float height = 6;
  bool has_height() const;
  private:
  bool _internal_has_height() const;
  public:
  void clear_height();
  float height() const;
  void set_height(float value);
  private:
  float _internal_height() const;
  void _internal_set_height(float value);
  public:

  // optional float shardsize = 7;
  bool has_shardsize() const;
  private:
  bool _internal_has_shardsize() const;
  public:
  void clear_shardsize();
  float shardsize() const;
  void set_shardsize(float value);
  private:
  float _internal_shardsize() const;
  void _internal_set_shardsize(float value);
  public:

  // optional uint32 surfacetype = 8;
  bool has_surfacetype() const;
  private:
  bool _internal_has_surfacetype() const;
  public:
  void clear_surfacetype();
  uint32_t surfacetype() const;
  void set_surfacetype(uint32_t value);
  private:
  uint32_t _internal_surfacetype() const;
  void _internal_set_surfacetype(uint32_t value);
  public:

  // optional fixed32 frontcolor = 9;
  bool has_frontcolor() const;
  private:
  bool _internal_has_frontcolor() const;
  public:
  void clear_frontcolor();
  uint32_t frontcolor() const;
  void set_frontcolor(uint32_t value);
  private:
  uint32_t _internal_frontcolor() const;
  void _internal_set_frontcolor(uint32_t value);
  public:

  // optional fixed32 backcolor = 10;
  bool has_backcolor() const;
  private:
  bool _internal_has_backcolor() const;
  public:
  void clear_backcolor();
  uint32_t backcolor() const;
  void set_backcolor(uint32_t value);
  private:
  uint32_t _internal_backcolor() const;
  void _internal_set_backcolor(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEShatterSurface)
 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* origin_;
    ::CMsgQAngle* angles_;
    ::CMsgVector* force_;
    ::CMsgVector* forcepos_;
    float width_;
    float height_;
    float shardsize_;
    uint32_t surfacetype_;
    uint32_t frontcolor_;
    uint32_t backcolor_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEGlowSprite";
  }
  protected:
  explicit CMsgTEGlowSprite(::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 {
    kOriginFieldNumber = 1,
    kScaleFieldNumber = 2,
    kLifeFieldNumber = 3,
    kBrightnessFieldNumber = 4,
  };
  // optional .CMsgVector origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

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

  // optional float life = 3;
  bool has_life() const;
  private:
  bool _internal_has_life() const;
  public:
  void clear_life();
  float life() const;
  void set_life(float value);
  private:
  float _internal_life() const;
  void _internal_set_life(float value);
  public:

  // optional uint32 brightness = 4;
  bool has_brightness() const;
  private:
  bool _internal_has_brightness() const;
  public:
  void clear_brightness();
  uint32_t brightness() const;
  void set_brightness(uint32_t value);
  private:
  uint32_t _internal_brightness() const;
  void _internal_set_brightness(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEGlowSprite)
 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* origin_;
    float scale_;
    float life_;
    uint32_t brightness_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEImpact";
  }
  protected:
  explicit CMsgTEImpact(::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 {
    kOriginFieldNumber = 1,
    kNormalFieldNumber = 2,
    kTypeFieldNumber = 3,
  };
  // optional .CMsgVector origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

  // optional .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 uint32 type = 3;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  uint32_t type() const;
  void set_type(uint32_t value);
  private:
  uint32_t _internal_type() const;
  void _internal_set_type(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEImpact)
 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* origin_;
    ::CMsgVector* normal_;
    uint32_t type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEMuzzleFlash";
  }
  protected:
  explicit CMsgTEMuzzleFlash(::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 {
    kOriginFieldNumber = 1,
    kAnglesFieldNumber = 2,
    kScaleFieldNumber = 3,
    kTypeFieldNumber = 4,
  };
  // optional .CMsgVector origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

  // optional .CMsgQAngle angles = 2;
  bool has_angles() const;
  private:
  bool _internal_has_angles() const;
  public:
  void clear_angles();
  const ::CMsgQAngle& angles() const;
  PROTOBUF_NODISCARD ::CMsgQAngle* release_angles();
  ::CMsgQAngle* mutable_angles();
  void set_allocated_angles(::CMsgQAngle* angles);
  private:
  const ::CMsgQAngle& _internal_angles() const;
  ::CMsgQAngle* _internal_mutable_angles();
  public:
  void unsafe_arena_set_allocated_angles(
      ::CMsgQAngle* angles);
  ::CMsgQAngle* unsafe_arena_release_angles();

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

  // optional uint32 type = 4;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  uint32_t type() const;
  void set_type(uint32_t value);
  private:
  uint32_t _internal_type() const;
  void _internal_set_type(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEMuzzleFlash)
 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* origin_;
    ::CMsgQAngle* angles_;
    float scale_;
    uint32_t type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEBloodStream";
  }
  protected:
  explicit CMsgTEBloodStream(::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 {
    kOriginFieldNumber = 1,
    kDirectionFieldNumber = 2,
    kColorFieldNumber = 3,
    kAmountFieldNumber = 4,
  };
  // optional .CMsgVector origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

  // optional .CMsgVector direction = 2;
  bool has_direction() const;
  private:
  bool _internal_has_direction() const;
  public:
  void clear_direction();
  const ::CMsgVector& direction() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_direction();
  ::CMsgVector* mutable_direction();
  void set_allocated_direction(::CMsgVector* direction);
  private:
  const ::CMsgVector& _internal_direction() const;
  ::CMsgVector* _internal_mutable_direction();
  public:
  void unsafe_arena_set_allocated_direction(
      ::CMsgVector* direction);
  ::CMsgVector* unsafe_arena_release_direction();

  // optional fixed32 color = 3;
  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 uint32 amount = 4;
  bool has_amount() const;
  private:
  bool _internal_has_amount() const;
  public:
  void clear_amount();
  uint32_t amount() const;
  void set_amount(uint32_t value);
  private:
  uint32_t _internal_amount() const;
  void _internal_set_amount(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEBloodStream)
 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* origin_;
    ::CMsgVector* direction_;
    uint32_t color_;
    uint32_t amount_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEExplosion";
  }
  protected:
  explicit CMsgTEExplosion(::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 {
    kSoundNameFieldNumber = 10,
    kOriginFieldNumber = 1,
    kNormalFieldNumber = 4,
    kDebrisOriginFieldNumber = 13,
    kFlagsFieldNumber = 3,
    kRadiusFieldNumber = 6,
    kMagnitudeFieldNumber = 7,
    kAffectRagdollsFieldNumber = 9,
    kCreateDebrisFieldNumber = 12,
    kExplosionTypeFieldNumber = 11,
    kDebrisSurfacepropFieldNumber = 14,
  };
  // optional string sound_name = 10;
  bool has_sound_name() const;
  private:
  bool _internal_has_sound_name() const;
  public:
  void clear_sound_name();
  const std::string& sound_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sound_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sound_name();
  PROTOBUF_NODISCARD std::string* release_sound_name();
  void set_allocated_sound_name(std::string* sound_name);
  private:
  const std::string& _internal_sound_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sound_name(const std::string& value);
  std::string* _internal_mutable_sound_name();
  public:

  // optional .CMsgVector origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

  // optional .CMsgVector normal = 4;
  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 debris_origin = 13;
  bool has_debris_origin() const;
  private:
  bool _internal_has_debris_origin() const;
  public:
  void clear_debris_origin();
  const ::CMsgVector& debris_origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_debris_origin();
  ::CMsgVector* mutable_debris_origin();
  void set_allocated_debris_origin(::CMsgVector* debris_origin);
  private:
  const ::CMsgVector& _internal_debris_origin() const;
  ::CMsgVector* _internal_mutable_debris_origin();
  public:
  void unsafe_arena_set_allocated_debris_origin(
      ::CMsgVector* debris_origin);
  ::CMsgVector* unsafe_arena_release_debris_origin();

  // optional uint32 flags = 3;
  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 uint32 radius = 6;
  bool has_radius() const;
  private:
  bool _internal_has_radius() const;
  public:
  void clear_radius();
  uint32_t radius() const;
  void set_radius(uint32_t value);
  private:
  uint32_t _internal_radius() const;
  void _internal_set_radius(uint32_t value);
  public:

  // optional uint32 magnitude = 7;
  bool has_magnitude() const;
  private:
  bool _internal_has_magnitude() const;
  public:
  void clear_magnitude();
  uint32_t magnitude() const;
  void set_magnitude(uint32_t value);
  private:
  uint32_t _internal_magnitude() const;
  void _internal_set_magnitude(uint32_t value);
  public:

  // optional bool affect_ragdolls = 9;
  bool has_affect_ragdolls() const;
  private:
  bool _internal_has_affect_ragdolls() const;
  public:
  void clear_affect_ragdolls();
  bool affect_ragdolls() const;
  void set_affect_ragdolls(bool value);
  private:
  bool _internal_affect_ragdolls() const;
  void _internal_set_affect_ragdolls(bool value);
  public:

  // optional bool create_debris = 12;
  bool has_create_debris() const;
  private:
  bool _internal_has_create_debris() const;
  public:
  void clear_create_debris();
  bool create_debris() const;
  void set_create_debris(bool value);
  private:
  bool _internal_create_debris() const;
  void _internal_set_create_debris(bool value);
  public:

  // optional uint32 explosion_type = 11;
  bool has_explosion_type() const;
  private:
  bool _internal_has_explosion_type() const;
  public:
  void clear_explosion_type();
  uint32_t explosion_type() const;
  void set_explosion_type(uint32_t value);
  private:
  uint32_t _internal_explosion_type() const;
  void _internal_set_explosion_type(uint32_t value);
  public:

  // optional fixed32 debris_surfaceprop = 14;
  bool has_debris_surfaceprop() const;
  private:
  bool _internal_has_debris_surfaceprop() const;
  public:
  void clear_debris_surfaceprop();
  uint32_t debris_surfaceprop() const;
  void set_debris_surfaceprop(uint32_t value);
  private:
  uint32_t _internal_debris_surfaceprop() const;
  void _internal_set_debris_surfaceprop(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEExplosion)
 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 sound_name_;
    ::CMsgVector* origin_;
    ::CMsgVector* normal_;
    ::CMsgVector* debris_origin_;
    uint32_t flags_;
    uint32_t radius_;
    uint32_t magnitude_;
    bool affect_ragdolls_;
    bool create_debris_;
    uint32_t explosion_type_;
    uint32_t debris_surfaceprop_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEDust";
  }
  protected:
  explicit CMsgTEDust(::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 {
    kOriginFieldNumber = 1,
    kDirectionFieldNumber = 4,
    kSizeFieldNumber = 2,
    kSpeedFieldNumber = 3,
  };
  // optional .CMsgVector origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

  // optional .CMsgVector direction = 4;
  bool has_direction() const;
  private:
  bool _internal_has_direction() const;
  public:
  void clear_direction();
  const ::CMsgVector& direction() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_direction();
  ::CMsgVector* mutable_direction();
  void set_allocated_direction(::CMsgVector* direction);
  private:
  const ::CMsgVector& _internal_direction() const;
  ::CMsgVector* _internal_mutable_direction();
  public:
  void unsafe_arena_set_allocated_direction(
      ::CMsgVector* direction);
  ::CMsgVector* unsafe_arena_release_direction();

  // optional float size = 2;
  bool has_size() const;
  private:
  bool _internal_has_size() const;
  public:
  void clear_size();
  float size() const;
  void set_size(float value);
  private:
  float _internal_size() const;
  void _internal_set_size(float value);
  public:

  // optional float speed = 3;
  bool has_speed() const;
  private:
  bool _internal_has_speed() const;
  public:
  void clear_speed();
  float speed() const;
  void set_speed(float value);
  private:
  float _internal_speed() const;
  void _internal_set_speed(float value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEDust)
 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* origin_;
    ::CMsgVector* direction_;
    float size_;
    float speed_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTELargeFunnel";
  }
  protected:
  explicit CMsgTELargeFunnel(::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 {
    kOriginFieldNumber = 1,
    kReversedFieldNumber = 2,
  };
  // optional .CMsgVector origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

  // optional uint32 reversed = 2;
  bool has_reversed() const;
  private:
  bool _internal_has_reversed() const;
  public:
  void clear_reversed();
  uint32_t reversed() const;
  void set_reversed(uint32_t value);
  private:
  uint32_t _internal_reversed() const;
  void _internal_set_reversed(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTELargeFunnel)
 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* origin_;
    uint32_t reversed_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTESparks";
  }
  protected:
  explicit CMsgTESparks(::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 {
    kOriginFieldNumber = 1,
    kDirectionFieldNumber = 4,
    kMagnitudeFieldNumber = 2,
    kLengthFieldNumber = 3,
  };
  // optional .CMsgVector origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

  // optional .CMsgVector direction = 4;
  bool has_direction() const;
  private:
  bool _internal_has_direction() const;
  public:
  void clear_direction();
  const ::CMsgVector& direction() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_direction();
  ::CMsgVector* mutable_direction();
  void set_allocated_direction(::CMsgVector* direction);
  private:
  const ::CMsgVector& _internal_direction() const;
  ::CMsgVector* _internal_mutable_direction();
  public:
  void unsafe_arena_set_allocated_direction(
      ::CMsgVector* direction);
  ::CMsgVector* unsafe_arena_release_direction();

  // optional uint32 magnitude = 2;
  bool has_magnitude() const;
  private:
  bool _internal_has_magnitude() const;
  public:
  void clear_magnitude();
  uint32_t magnitude() const;
  void set_magnitude(uint32_t value);
  private:
  uint32_t _internal_magnitude() const;
  void _internal_set_magnitude(uint32_t value);
  public:

  // optional uint32 length = 3;
  bool has_length() const;
  private:
  bool _internal_has_length() const;
  public:
  void clear_length();
  uint32_t length() const;
  void set_length(uint32_t value);
  private:
  uint32_t _internal_length() const;
  void _internal_set_length(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTESparks)
 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* origin_;
    ::CMsgVector* direction_;
    uint32_t magnitude_;
    uint32_t length_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEPhysicsProp";
  }
  protected:
  explicit CMsgTEPhysicsProp(::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 {
    kOriginFieldNumber = 1,
    kVelocityFieldNumber = 2,
    kAnglesFieldNumber = 3,
    kDmgposFieldNumber = 11,
    kDmgdirFieldNumber = 12,
    kSkinFieldNumber = 4,
    kFlagsFieldNumber = 5,
    kEffectsFieldNumber = 6,
    kColorFieldNumber = 7,
    kModelindexFieldNumber = 8,
    kUnusedBreakmodelsnottomakeFieldNumber = 9,
    kScaleFieldNumber = 10,
    kDmgtypeFieldNumber = 13,
  };
  // optional .CMsgVector origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

  // optional .CMsgVector velocity = 2;
  bool has_velocity() const;
  private:
  bool _internal_has_velocity() const;
  public:
  void clear_velocity();
  const ::CMsgVector& velocity() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_velocity();
  ::CMsgVector* mutable_velocity();
  void set_allocated_velocity(::CMsgVector* velocity);
  private:
  const ::CMsgVector& _internal_velocity() const;
  ::CMsgVector* _internal_mutable_velocity();
  public:
  void unsafe_arena_set_allocated_velocity(
      ::CMsgVector* velocity);
  ::CMsgVector* unsafe_arena_release_velocity();

  // optional .CMsgQAngle angles = 3;
  bool has_angles() const;
  private:
  bool _internal_has_angles() const;
  public:
  void clear_angles();
  const ::CMsgQAngle& angles() const;
  PROTOBUF_NODISCARD ::CMsgQAngle* release_angles();
  ::CMsgQAngle* mutable_angles();
  void set_allocated_angles(::CMsgQAngle* angles);
  private:
  const ::CMsgQAngle& _internal_angles() const;
  ::CMsgQAngle* _internal_mutable_angles();
  public:
  void unsafe_arena_set_allocated_angles(
      ::CMsgQAngle* angles);
  ::CMsgQAngle* unsafe_arena_release_angles();

  // optional .CMsgVector dmgpos = 11;
  bool has_dmgpos() const;
  private:
  bool _internal_has_dmgpos() const;
  public:
  void clear_dmgpos();
  const ::CMsgVector& dmgpos() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_dmgpos();
  ::CMsgVector* mutable_dmgpos();
  void set_allocated_dmgpos(::CMsgVector* dmgpos);
  private:
  const ::CMsgVector& _internal_dmgpos() const;
  ::CMsgVector* _internal_mutable_dmgpos();
  public:
  void unsafe_arena_set_allocated_dmgpos(
      ::CMsgVector* dmgpos);
  ::CMsgVector* unsafe_arena_release_dmgpos();

  // optional .CMsgVector dmgdir = 12;
  bool has_dmgdir() const;
  private:
  bool _internal_has_dmgdir() const;
  public:
  void clear_dmgdir();
  const ::CMsgVector& dmgdir() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_dmgdir();
  ::CMsgVector* mutable_dmgdir();
  void set_allocated_dmgdir(::CMsgVector* dmgdir);
  private:
  const ::CMsgVector& _internal_dmgdir() const;
  ::CMsgVector* _internal_mutable_dmgdir();
  public:
  void unsafe_arena_set_allocated_dmgdir(
      ::CMsgVector* dmgdir);
  ::CMsgVector* unsafe_arena_release_dmgdir();

  // optional fixed32 skin = 4;
  bool has_skin() const;
  private:
  bool _internal_has_skin() const;
  public:
  void clear_skin();
  uint32_t skin() const;
  void set_skin(uint32_t value);
  private:
  uint32_t _internal_skin() const;
  void _internal_set_skin(uint32_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 uint32 effects = 6;
  bool has_effects() const;
  private:
  bool _internal_has_effects() const;
  public:
  void clear_effects();
  uint32_t effects() const;
  void set_effects(uint32_t value);
  private:
  uint32_t _internal_effects() const;
  void _internal_set_effects(uint32_t value);
  public:

  // optional fixed32 color = 7;
  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 fixed64 modelindex = 8;
  bool has_modelindex() const;
  private:
  bool _internal_has_modelindex() const;
  public:
  void clear_modelindex();
  uint64_t modelindex() const;
  void set_modelindex(uint64_t value);
  private:
  uint64_t _internal_modelindex() const;
  void _internal_set_modelindex(uint64_t value);
  public:

  // optional uint32 unused_breakmodelsnottomake = 9;
  bool has_unused_breakmodelsnottomake() const;
  private:
  bool _internal_has_unused_breakmodelsnottomake() const;
  public:
  void clear_unused_breakmodelsnottomake();
  uint32_t unused_breakmodelsnottomake() const;
  void set_unused_breakmodelsnottomake(uint32_t value);
  private:
  uint32_t _internal_unused_breakmodelsnottomake() const;
  void _internal_set_unused_breakmodelsnottomake(uint32_t value);
  public:

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

  // optional int32 dmgtype = 13;
  bool has_dmgtype() const;
  private:
  bool _internal_has_dmgtype() const;
  public:
  void clear_dmgtype();
  int32_t dmgtype() const;
  void set_dmgtype(int32_t value);
  private:
  int32_t _internal_dmgtype() const;
  void _internal_set_dmgtype(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEPhysicsProp)
 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* origin_;
    ::CMsgVector* velocity_;
    ::CMsgQAngle* angles_;
    ::CMsgVector* dmgpos_;
    ::CMsgVector* dmgdir_;
    uint32_t skin_;
    uint32_t flags_;
    uint32_t effects_;
    uint32_t color_;
    uint64_t modelindex_;
    uint32_t unused_breakmodelsnottomake_;
    float scale_;
    int32_t dmgtype_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTESmoke";
  }
  protected:
  explicit CMsgTESmoke(::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 {
    kOriginFieldNumber = 1,
    kScaleFieldNumber = 2,
  };
  // optional .CMsgVector origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

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

  // @@protoc_insertion_point(class_scope:CMsgTESmoke)
 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* origin_;
    float scale_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTEWorldDecal";
  }
  protected:
  explicit CMsgTEWorldDecal(::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 {
    kOriginFieldNumber = 1,
    kNormalFieldNumber = 2,
    kIndexFieldNumber = 3,
  };
  // optional .CMsgVector origin = 1;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  const ::CMsgVector& origin() const;
  PROTOBUF_NODISCARD ::CMsgVector* release_origin();
  ::CMsgVector* mutable_origin();
  void set_allocated_origin(::CMsgVector* origin);
  private:
  const ::CMsgVector& _internal_origin() const;
  ::CMsgVector* _internal_mutable_origin();
  public:
  void unsafe_arena_set_allocated_origin(
      ::CMsgVector* origin);
  ::CMsgVector* unsafe_arena_release_origin();

  // optional .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 uint32 index = 3;
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  uint32_t index() const;
  void set_index(uint32_t value);
  private:
  uint32_t _internal_index() const;
  void _internal_set_index(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgTEWorldDecal)
 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* origin_;
    ::CMsgVector* normal_;
    uint32_t index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_te_2eproto;
};
// ===================================================================


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

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

// optional .CMsgVector pos = 1;
inline bool CMsgTEArmorRicochet::_internal_has_pos() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pos_ != nullptr);
  return value;
}
inline bool CMsgTEArmorRicochet::has_pos() const {
  return _internal_has_pos();
}
inline const ::CMsgVector& CMsgTEArmorRicochet::_internal_pos() const {
  const ::CMsgVector* p = _impl_.pos_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEArmorRicochet::pos() const {
  // @@protoc_insertion_point(field_get:CMsgTEArmorRicochet.pos)
  return _internal_pos();
}
inline void CMsgTEArmorRicochet::unsafe_arena_set_allocated_pos(
    ::CMsgVector* pos) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pos_);
  }
  _impl_.pos_ = pos;
  if (pos) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEArmorRicochet.pos)
}
inline ::CMsgVector* CMsgTEArmorRicochet::release_pos() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.pos_;
  _impl_.pos_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTEArmorRicochet::unsafe_arena_release_pos() {
  // @@protoc_insertion_point(field_release:CMsgTEArmorRicochet.pos)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.pos_;
  _impl_.pos_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEArmorRicochet::_internal_mutable_pos() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.pos_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.pos_ = p;
  }
  return _impl_.pos_;
}
inline ::CMsgVector* CMsgTEArmorRicochet::mutable_pos() {
  ::CMsgVector* _msg = _internal_mutable_pos();
  // @@protoc_insertion_point(field_mutable:CMsgTEArmorRicochet.pos)
  return _msg;
}
inline void CMsgTEArmorRicochet::set_allocated_pos(::CMsgVector* pos) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pos_);
  }
  if (pos) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(pos));
    if (message_arena != submessage_arena) {
      pos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pos, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.pos_ = pos;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEArmorRicochet.pos)
}

// optional .CMsgVector dir = 2;
inline bool CMsgTEArmorRicochet::_internal_has_dir() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.dir_ != nullptr);
  return value;
}
inline bool CMsgTEArmorRicochet::has_dir() const {
  return _internal_has_dir();
}
inline const ::CMsgVector& CMsgTEArmorRicochet::_internal_dir() const {
  const ::CMsgVector* p = _impl_.dir_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEArmorRicochet::dir() const {
  // @@protoc_insertion_point(field_get:CMsgTEArmorRicochet.dir)
  return _internal_dir();
}
inline void CMsgTEArmorRicochet::unsafe_arena_set_allocated_dir(
    ::CMsgVector* dir) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dir_);
  }
  _impl_.dir_ = dir;
  if (dir) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEArmorRicochet.dir)
}
inline ::CMsgVector* CMsgTEArmorRicochet::release_dir() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.dir_;
  _impl_.dir_ = 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* CMsgTEArmorRicochet::unsafe_arena_release_dir() {
  // @@protoc_insertion_point(field_release:CMsgTEArmorRicochet.dir)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.dir_;
  _impl_.dir_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEArmorRicochet::_internal_mutable_dir() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.dir_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.dir_ = p;
  }
  return _impl_.dir_;
}
inline ::CMsgVector* CMsgTEArmorRicochet::mutable_dir() {
  ::CMsgVector* _msg = _internal_mutable_dir();
  // @@protoc_insertion_point(field_mutable:CMsgTEArmorRicochet.dir)
  return _msg;
}
inline void CMsgTEArmorRicochet::set_allocated_dir(::CMsgVector* dir) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dir_);
  }
  if (dir) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dir));
    if (message_arena != submessage_arena) {
      dir = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dir, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.dir_ = dir;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEArmorRicochet.dir)
}

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

// CMsgTEBaseBeam

// optional fixed64 modelindex = 1;
inline bool CMsgTEBaseBeam::_internal_has_modelindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgTEBaseBeam::has_modelindex() const {
  return _internal_has_modelindex();
}
inline void CMsgTEBaseBeam::clear_modelindex() {
  _impl_.modelindex_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgTEBaseBeam::_internal_modelindex() const {
  return _impl_.modelindex_;
}
inline uint64_t CMsgTEBaseBeam::modelindex() const {
  // @@protoc_insertion_point(field_get:CMsgTEBaseBeam.modelindex)
  return _internal_modelindex();
}
inline void CMsgTEBaseBeam::_internal_set_modelindex(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.modelindex_ = value;
}
inline void CMsgTEBaseBeam::set_modelindex(uint64_t value) {
  _internal_set_modelindex(value);
  // @@protoc_insertion_point(field_set:CMsgTEBaseBeam.modelindex)
}

// optional fixed64 haloindex = 2;
inline bool CMsgTEBaseBeam::_internal_has_haloindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgTEBaseBeam::has_haloindex() const {
  return _internal_has_haloindex();
}
inline void CMsgTEBaseBeam::clear_haloindex() {
  _impl_.haloindex_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgTEBaseBeam::_internal_haloindex() const {
  return _impl_.haloindex_;
}
inline uint64_t CMsgTEBaseBeam::haloindex() const {
  // @@protoc_insertion_point(field_get:CMsgTEBaseBeam.haloindex)
  return _internal_haloindex();
}
inline void CMsgTEBaseBeam::_internal_set_haloindex(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.haloindex_ = value;
}
inline void CMsgTEBaseBeam::set_haloindex(uint64_t value) {
  _internal_set_haloindex(value);
  // @@protoc_insertion_point(field_set:CMsgTEBaseBeam.haloindex)
}

// optional uint32 startframe = 3;
inline bool CMsgTEBaseBeam::_internal_has_startframe() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgTEBaseBeam::has_startframe() const {
  return _internal_has_startframe();
}
inline void CMsgTEBaseBeam::clear_startframe() {
  _impl_.startframe_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgTEBaseBeam::_internal_startframe() const {
  return _impl_.startframe_;
}
inline uint32_t CMsgTEBaseBeam::startframe() const {
  // @@protoc_insertion_point(field_get:CMsgTEBaseBeam.startframe)
  return _internal_startframe();
}
inline void CMsgTEBaseBeam::_internal_set_startframe(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.startframe_ = value;
}
inline void CMsgTEBaseBeam::set_startframe(uint32_t value) {
  _internal_set_startframe(value);
  // @@protoc_insertion_point(field_set:CMsgTEBaseBeam.startframe)
}

// optional uint32 framerate = 4;
inline bool CMsgTEBaseBeam::_internal_has_framerate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgTEBaseBeam::has_framerate() const {
  return _internal_has_framerate();
}
inline void CMsgTEBaseBeam::clear_framerate() {
  _impl_.framerate_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgTEBaseBeam::_internal_framerate() const {
  return _impl_.framerate_;
}
inline uint32_t CMsgTEBaseBeam::framerate() const {
  // @@protoc_insertion_point(field_get:CMsgTEBaseBeam.framerate)
  return _internal_framerate();
}
inline void CMsgTEBaseBeam::_internal_set_framerate(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.framerate_ = value;
}
inline void CMsgTEBaseBeam::set_framerate(uint32_t value) {
  _internal_set_framerate(value);
  // @@protoc_insertion_point(field_set:CMsgTEBaseBeam.framerate)
}

// optional float life = 5;
inline bool CMsgTEBaseBeam::_internal_has_life() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgTEBaseBeam::has_life() const {
  return _internal_has_life();
}
inline void CMsgTEBaseBeam::clear_life() {
  _impl_.life_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float CMsgTEBaseBeam::_internal_life() const {
  return _impl_.life_;
}
inline float CMsgTEBaseBeam::life() const {
  // @@protoc_insertion_point(field_get:CMsgTEBaseBeam.life)
  return _internal_life();
}
inline void CMsgTEBaseBeam::_internal_set_life(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.life_ = value;
}
inline void CMsgTEBaseBeam::set_life(float value) {
  _internal_set_life(value);
  // @@protoc_insertion_point(field_set:CMsgTEBaseBeam.life)
}

// optional float width = 6;
inline bool CMsgTEBaseBeam::_internal_has_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgTEBaseBeam::has_width() const {
  return _internal_has_width();
}
inline void CMsgTEBaseBeam::clear_width() {
  _impl_.width_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float CMsgTEBaseBeam::_internal_width() const {
  return _impl_.width_;
}
inline float CMsgTEBaseBeam::width() const {
  // @@protoc_insertion_point(field_get:CMsgTEBaseBeam.width)
  return _internal_width();
}
inline void CMsgTEBaseBeam::_internal_set_width(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.width_ = value;
}
inline void CMsgTEBaseBeam::set_width(float value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:CMsgTEBaseBeam.width)
}

// optional float endwidth = 7;
inline bool CMsgTEBaseBeam::_internal_has_endwidth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgTEBaseBeam::has_endwidth() const {
  return _internal_has_endwidth();
}
inline void CMsgTEBaseBeam::clear_endwidth() {
  _impl_.endwidth_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float CMsgTEBaseBeam::_internal_endwidth() const {
  return _impl_.endwidth_;
}
inline float CMsgTEBaseBeam::endwidth() const {
  // @@protoc_insertion_point(field_get:CMsgTEBaseBeam.endwidth)
  return _internal_endwidth();
}
inline void CMsgTEBaseBeam::_internal_set_endwidth(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.endwidth_ = value;
}
inline void CMsgTEBaseBeam::set_endwidth(float value) {
  _internal_set_endwidth(value);
  // @@protoc_insertion_point(field_set:CMsgTEBaseBeam.endwidth)
}

// optional uint32 fadelength = 8;
inline bool CMsgTEBaseBeam::_internal_has_fadelength() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgTEBaseBeam::has_fadelength() const {
  return _internal_has_fadelength();
}
inline void CMsgTEBaseBeam::clear_fadelength() {
  _impl_.fadelength_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgTEBaseBeam::_internal_fadelength() const {
  return _impl_.fadelength_;
}
inline uint32_t CMsgTEBaseBeam::fadelength() const {
  // @@protoc_insertion_point(field_get:CMsgTEBaseBeam.fadelength)
  return _internal_fadelength();
}
inline void CMsgTEBaseBeam::_internal_set_fadelength(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.fadelength_ = value;
}
inline void CMsgTEBaseBeam::set_fadelength(uint32_t value) {
  _internal_set_fadelength(value);
  // @@protoc_insertion_point(field_set:CMsgTEBaseBeam.fadelength)
}

// optional float amplitude = 9;
inline bool CMsgTEBaseBeam::_internal_has_amplitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgTEBaseBeam::has_amplitude() const {
  return _internal_has_amplitude();
}
inline void CMsgTEBaseBeam::clear_amplitude() {
  _impl_.amplitude_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline float CMsgTEBaseBeam::_internal_amplitude() const {
  return _impl_.amplitude_;
}
inline float CMsgTEBaseBeam::amplitude() const {
  // @@protoc_insertion_point(field_get:CMsgTEBaseBeam.amplitude)
  return _internal_amplitude();
}
inline void CMsgTEBaseBeam::_internal_set_amplitude(float value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.amplitude_ = value;
}
inline void CMsgTEBaseBeam::set_amplitude(float value) {
  _internal_set_amplitude(value);
  // @@protoc_insertion_point(field_set:CMsgTEBaseBeam.amplitude)
}

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

// optional uint32 speed = 11;
inline bool CMsgTEBaseBeam::_internal_has_speed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgTEBaseBeam::has_speed() const {
  return _internal_has_speed();
}
inline void CMsgTEBaseBeam::clear_speed() {
  _impl_.speed_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CMsgTEBaseBeam::_internal_speed() const {
  return _impl_.speed_;
}
inline uint32_t CMsgTEBaseBeam::speed() const {
  // @@protoc_insertion_point(field_get:CMsgTEBaseBeam.speed)
  return _internal_speed();
}
inline void CMsgTEBaseBeam::_internal_set_speed(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.speed_ = value;
}
inline void CMsgTEBaseBeam::set_speed(uint32_t value) {
  _internal_set_speed(value);
  // @@protoc_insertion_point(field_set:CMsgTEBaseBeam.speed)
}

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

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

// CMsgTEBeamEntPoint

// optional .CMsgTEBaseBeam base = 1;
inline bool CMsgTEBeamEntPoint::_internal_has_base() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.base_ != nullptr);
  return value;
}
inline bool CMsgTEBeamEntPoint::has_base() const {
  return _internal_has_base();
}
inline void CMsgTEBeamEntPoint::clear_base() {
  if (_impl_.base_ != nullptr) _impl_.base_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsgTEBaseBeam& CMsgTEBeamEntPoint::_internal_base() const {
  const ::CMsgTEBaseBeam* p = _impl_.base_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgTEBaseBeam&>(
      ::_CMsgTEBaseBeam_default_instance_);
}
inline const ::CMsgTEBaseBeam& CMsgTEBeamEntPoint::base() const {
  // @@protoc_insertion_point(field_get:CMsgTEBeamEntPoint.base)
  return _internal_base();
}
inline void CMsgTEBeamEntPoint::unsafe_arena_set_allocated_base(
    ::CMsgTEBaseBeam* base) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.base_);
  }
  _impl_.base_ = base;
  if (base) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEBeamEntPoint.base)
}
inline ::CMsgTEBaseBeam* CMsgTEBeamEntPoint::release_base() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgTEBaseBeam* temp = _impl_.base_;
  _impl_.base_ = 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 ::CMsgTEBaseBeam* CMsgTEBeamEntPoint::unsafe_arena_release_base() {
  // @@protoc_insertion_point(field_release:CMsgTEBeamEntPoint.base)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgTEBaseBeam* temp = _impl_.base_;
  _impl_.base_ = nullptr;
  return temp;
}
inline ::CMsgTEBaseBeam* CMsgTEBeamEntPoint::_internal_mutable_base() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.base_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgTEBaseBeam>(GetArenaForAllocation());
    _impl_.base_ = p;
  }
  return _impl_.base_;
}
inline ::CMsgTEBaseBeam* CMsgTEBeamEntPoint::mutable_base() {
  ::CMsgTEBaseBeam* _msg = _internal_mutable_base();
  // @@protoc_insertion_point(field_mutable:CMsgTEBeamEntPoint.base)
  return _msg;
}
inline void CMsgTEBeamEntPoint::set_allocated_base(::CMsgTEBaseBeam* base) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.base_;
  }
  if (base) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(base);
    if (message_arena != submessage_arena) {
      base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, base, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.base_ = base;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEBeamEntPoint.base)
}

// optional uint32 startentity = 2;
inline bool CMsgTEBeamEntPoint::_internal_has_startentity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgTEBeamEntPoint::has_startentity() const {
  return _internal_has_startentity();
}
inline void CMsgTEBeamEntPoint::clear_startentity() {
  _impl_.startentity_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgTEBeamEntPoint::_internal_startentity() const {
  return _impl_.startentity_;
}
inline uint32_t CMsgTEBeamEntPoint::startentity() const {
  // @@protoc_insertion_point(field_get:CMsgTEBeamEntPoint.startentity)
  return _internal_startentity();
}
inline void CMsgTEBeamEntPoint::_internal_set_startentity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.startentity_ = value;
}
inline void CMsgTEBeamEntPoint::set_startentity(uint32_t value) {
  _internal_set_startentity(value);
  // @@protoc_insertion_point(field_set:CMsgTEBeamEntPoint.startentity)
}

// optional uint32 endentity = 3;
inline bool CMsgTEBeamEntPoint::_internal_has_endentity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgTEBeamEntPoint::has_endentity() const {
  return _internal_has_endentity();
}
inline void CMsgTEBeamEntPoint::clear_endentity() {
  _impl_.endentity_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgTEBeamEntPoint::_internal_endentity() const {
  return _impl_.endentity_;
}
inline uint32_t CMsgTEBeamEntPoint::endentity() const {
  // @@protoc_insertion_point(field_get:CMsgTEBeamEntPoint.endentity)
  return _internal_endentity();
}
inline void CMsgTEBeamEntPoint::_internal_set_endentity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.endentity_ = value;
}
inline void CMsgTEBeamEntPoint::set_endentity(uint32_t value) {
  _internal_set_endentity(value);
  // @@protoc_insertion_point(field_set:CMsgTEBeamEntPoint.endentity)
}

// optional .CMsgVector start = 4;
inline bool CMsgTEBeamEntPoint::_internal_has_start() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.start_ != nullptr);
  return value;
}
inline bool CMsgTEBeamEntPoint::has_start() const {
  return _internal_has_start();
}
inline const ::CMsgVector& CMsgTEBeamEntPoint::_internal_start() const {
  const ::CMsgVector* p = _impl_.start_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEBeamEntPoint::start() const {
  // @@protoc_insertion_point(field_get:CMsgTEBeamEntPoint.start)
  return _internal_start();
}
inline void CMsgTEBeamEntPoint::unsafe_arena_set_allocated_start(
    ::CMsgVector* start) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_);
  }
  _impl_.start_ = start;
  if (start) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEBeamEntPoint.start)
}
inline ::CMsgVector* CMsgTEBeamEntPoint::release_start() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.start_;
  _impl_.start_ = 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* CMsgTEBeamEntPoint::unsafe_arena_release_start() {
  // @@protoc_insertion_point(field_release:CMsgTEBeamEntPoint.start)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.start_;
  _impl_.start_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEBeamEntPoint::_internal_mutable_start() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.start_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.start_ = p;
  }
  return _impl_.start_;
}
inline ::CMsgVector* CMsgTEBeamEntPoint::mutable_start() {
  ::CMsgVector* _msg = _internal_mutable_start();
  // @@protoc_insertion_point(field_mutable:CMsgTEBeamEntPoint.start)
  return _msg;
}
inline void CMsgTEBeamEntPoint::set_allocated_start(::CMsgVector* start) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_);
  }
  if (start) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(start));
    if (message_arena != submessage_arena) {
      start = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, start, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.start_ = start;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEBeamEntPoint.start)
}

// optional .CMsgVector end = 5;
inline bool CMsgTEBeamEntPoint::_internal_has_end() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.end_ != nullptr);
  return value;
}
inline bool CMsgTEBeamEntPoint::has_end() const {
  return _internal_has_end();
}
inline const ::CMsgVector& CMsgTEBeamEntPoint::_internal_end() const {
  const ::CMsgVector* p = _impl_.end_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEBeamEntPoint::end() const {
  // @@protoc_insertion_point(field_get:CMsgTEBeamEntPoint.end)
  return _internal_end();
}
inline void CMsgTEBeamEntPoint::unsafe_arena_set_allocated_end(
    ::CMsgVector* end) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.end_);
  }
  _impl_.end_ = end;
  if (end) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEBeamEntPoint.end)
}
inline ::CMsgVector* CMsgTEBeamEntPoint::release_end() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.end_;
  _impl_.end_ = 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* CMsgTEBeamEntPoint::unsafe_arena_release_end() {
  // @@protoc_insertion_point(field_release:CMsgTEBeamEntPoint.end)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.end_;
  _impl_.end_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEBeamEntPoint::_internal_mutable_end() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.end_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.end_ = p;
  }
  return _impl_.end_;
}
inline ::CMsgVector* CMsgTEBeamEntPoint::mutable_end() {
  ::CMsgVector* _msg = _internal_mutable_end();
  // @@protoc_insertion_point(field_mutable:CMsgTEBeamEntPoint.end)
  return _msg;
}
inline void CMsgTEBeamEntPoint::set_allocated_end(::CMsgVector* end) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.end_);
  }
  if (end) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(end));
    if (message_arena != submessage_arena) {
      end = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, end, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.end_ = end;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEBeamEntPoint.end)
}

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

// CMsgTEBeamEnts

// optional .CMsgTEBaseBeam base = 1;
inline bool CMsgTEBeamEnts::_internal_has_base() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.base_ != nullptr);
  return value;
}
inline bool CMsgTEBeamEnts::has_base() const {
  return _internal_has_base();
}
inline void CMsgTEBeamEnts::clear_base() {
  if (_impl_.base_ != nullptr) _impl_.base_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsgTEBaseBeam& CMsgTEBeamEnts::_internal_base() const {
  const ::CMsgTEBaseBeam* p = _impl_.base_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgTEBaseBeam&>(
      ::_CMsgTEBaseBeam_default_instance_);
}
inline const ::CMsgTEBaseBeam& CMsgTEBeamEnts::base() const {
  // @@protoc_insertion_point(field_get:CMsgTEBeamEnts.base)
  return _internal_base();
}
inline void CMsgTEBeamEnts::unsafe_arena_set_allocated_base(
    ::CMsgTEBaseBeam* base) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.base_);
  }
  _impl_.base_ = base;
  if (base) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEBeamEnts.base)
}
inline ::CMsgTEBaseBeam* CMsgTEBeamEnts::release_base() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgTEBaseBeam* temp = _impl_.base_;
  _impl_.base_ = 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 ::CMsgTEBaseBeam* CMsgTEBeamEnts::unsafe_arena_release_base() {
  // @@protoc_insertion_point(field_release:CMsgTEBeamEnts.base)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgTEBaseBeam* temp = _impl_.base_;
  _impl_.base_ = nullptr;
  return temp;
}
inline ::CMsgTEBaseBeam* CMsgTEBeamEnts::_internal_mutable_base() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.base_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgTEBaseBeam>(GetArenaForAllocation());
    _impl_.base_ = p;
  }
  return _impl_.base_;
}
inline ::CMsgTEBaseBeam* CMsgTEBeamEnts::mutable_base() {
  ::CMsgTEBaseBeam* _msg = _internal_mutable_base();
  // @@protoc_insertion_point(field_mutable:CMsgTEBeamEnts.base)
  return _msg;
}
inline void CMsgTEBeamEnts::set_allocated_base(::CMsgTEBaseBeam* base) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.base_;
  }
  if (base) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(base);
    if (message_arena != submessage_arena) {
      base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, base, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.base_ = base;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEBeamEnts.base)
}

// optional uint32 startentity = 2;
inline bool CMsgTEBeamEnts::_internal_has_startentity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgTEBeamEnts::has_startentity() const {
  return _internal_has_startentity();
}
inline void CMsgTEBeamEnts::clear_startentity() {
  _impl_.startentity_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgTEBeamEnts::_internal_startentity() const {
  return _impl_.startentity_;
}
inline uint32_t CMsgTEBeamEnts::startentity() const {
  // @@protoc_insertion_point(field_get:CMsgTEBeamEnts.startentity)
  return _internal_startentity();
}
inline void CMsgTEBeamEnts::_internal_set_startentity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.startentity_ = value;
}
inline void CMsgTEBeamEnts::set_startentity(uint32_t value) {
  _internal_set_startentity(value);
  // @@protoc_insertion_point(field_set:CMsgTEBeamEnts.startentity)
}

// optional uint32 endentity = 3;
inline bool CMsgTEBeamEnts::_internal_has_endentity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgTEBeamEnts::has_endentity() const {
  return _internal_has_endentity();
}
inline void CMsgTEBeamEnts::clear_endentity() {
  _impl_.endentity_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgTEBeamEnts::_internal_endentity() const {
  return _impl_.endentity_;
}
inline uint32_t CMsgTEBeamEnts::endentity() const {
  // @@protoc_insertion_point(field_get:CMsgTEBeamEnts.endentity)
  return _internal_endentity();
}
inline void CMsgTEBeamEnts::_internal_set_endentity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.endentity_ = value;
}
inline void CMsgTEBeamEnts::set_endentity(uint32_t value) {
  _internal_set_endentity(value);
  // @@protoc_insertion_point(field_set:CMsgTEBeamEnts.endentity)
}

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

// CMsgTEBeamPoints

// optional .CMsgTEBaseBeam base = 1;
inline bool CMsgTEBeamPoints::_internal_has_base() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.base_ != nullptr);
  return value;
}
inline bool CMsgTEBeamPoints::has_base() const {
  return _internal_has_base();
}
inline void CMsgTEBeamPoints::clear_base() {
  if (_impl_.base_ != nullptr) _impl_.base_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsgTEBaseBeam& CMsgTEBeamPoints::_internal_base() const {
  const ::CMsgTEBaseBeam* p = _impl_.base_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgTEBaseBeam&>(
      ::_CMsgTEBaseBeam_default_instance_);
}
inline const ::CMsgTEBaseBeam& CMsgTEBeamPoints::base() const {
  // @@protoc_insertion_point(field_get:CMsgTEBeamPoints.base)
  return _internal_base();
}
inline void CMsgTEBeamPoints::unsafe_arena_set_allocated_base(
    ::CMsgTEBaseBeam* base) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.base_);
  }
  _impl_.base_ = base;
  if (base) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEBeamPoints.base)
}
inline ::CMsgTEBaseBeam* CMsgTEBeamPoints::release_base() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgTEBaseBeam* temp = _impl_.base_;
  _impl_.base_ = 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 ::CMsgTEBaseBeam* CMsgTEBeamPoints::unsafe_arena_release_base() {
  // @@protoc_insertion_point(field_release:CMsgTEBeamPoints.base)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgTEBaseBeam* temp = _impl_.base_;
  _impl_.base_ = nullptr;
  return temp;
}
inline ::CMsgTEBaseBeam* CMsgTEBeamPoints::_internal_mutable_base() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.base_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgTEBaseBeam>(GetArenaForAllocation());
    _impl_.base_ = p;
  }
  return _impl_.base_;
}
inline ::CMsgTEBaseBeam* CMsgTEBeamPoints::mutable_base() {
  ::CMsgTEBaseBeam* _msg = _internal_mutable_base();
  // @@protoc_insertion_point(field_mutable:CMsgTEBeamPoints.base)
  return _msg;
}
inline void CMsgTEBeamPoints::set_allocated_base(::CMsgTEBaseBeam* base) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.base_;
  }
  if (base) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(base);
    if (message_arena != submessage_arena) {
      base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, base, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.base_ = base;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEBeamPoints.base)
}

// optional .CMsgVector start = 2;
inline bool CMsgTEBeamPoints::_internal_has_start() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.start_ != nullptr);
  return value;
}
inline bool CMsgTEBeamPoints::has_start() const {
  return _internal_has_start();
}
inline const ::CMsgVector& CMsgTEBeamPoints::_internal_start() const {
  const ::CMsgVector* p = _impl_.start_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEBeamPoints::start() const {
  // @@protoc_insertion_point(field_get:CMsgTEBeamPoints.start)
  return _internal_start();
}
inline void CMsgTEBeamPoints::unsafe_arena_set_allocated_start(
    ::CMsgVector* start) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_);
  }
  _impl_.start_ = start;
  if (start) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEBeamPoints.start)
}
inline ::CMsgVector* CMsgTEBeamPoints::release_start() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.start_;
  _impl_.start_ = 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* CMsgTEBeamPoints::unsafe_arena_release_start() {
  // @@protoc_insertion_point(field_release:CMsgTEBeamPoints.start)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.start_;
  _impl_.start_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEBeamPoints::_internal_mutable_start() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.start_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.start_ = p;
  }
  return _impl_.start_;
}
inline ::CMsgVector* CMsgTEBeamPoints::mutable_start() {
  ::CMsgVector* _msg = _internal_mutable_start();
  // @@protoc_insertion_point(field_mutable:CMsgTEBeamPoints.start)
  return _msg;
}
inline void CMsgTEBeamPoints::set_allocated_start(::CMsgVector* start) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_);
  }
  if (start) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(start));
    if (message_arena != submessage_arena) {
      start = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, start, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.start_ = start;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEBeamPoints.start)
}

// optional .CMsgVector end = 3;
inline bool CMsgTEBeamPoints::_internal_has_end() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.end_ != nullptr);
  return value;
}
inline bool CMsgTEBeamPoints::has_end() const {
  return _internal_has_end();
}
inline const ::CMsgVector& CMsgTEBeamPoints::_internal_end() const {
  const ::CMsgVector* p = _impl_.end_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEBeamPoints::end() const {
  // @@protoc_insertion_point(field_get:CMsgTEBeamPoints.end)
  return _internal_end();
}
inline void CMsgTEBeamPoints::unsafe_arena_set_allocated_end(
    ::CMsgVector* end) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.end_);
  }
  _impl_.end_ = end;
  if (end) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEBeamPoints.end)
}
inline ::CMsgVector* CMsgTEBeamPoints::release_end() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.end_;
  _impl_.end_ = 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* CMsgTEBeamPoints::unsafe_arena_release_end() {
  // @@protoc_insertion_point(field_release:CMsgTEBeamPoints.end)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.end_;
  _impl_.end_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEBeamPoints::_internal_mutable_end() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.end_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.end_ = p;
  }
  return _impl_.end_;
}
inline ::CMsgVector* CMsgTEBeamPoints::mutable_end() {
  ::CMsgVector* _msg = _internal_mutable_end();
  // @@protoc_insertion_point(field_mutable:CMsgTEBeamPoints.end)
  return _msg;
}
inline void CMsgTEBeamPoints::set_allocated_end(::CMsgVector* end) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.end_);
  }
  if (end) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(end));
    if (message_arena != submessage_arena) {
      end = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, end, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.end_ = end;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEBeamPoints.end)
}

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

// CMsgTEBeamRing

// optional .CMsgTEBaseBeam base = 1;
inline bool CMsgTEBeamRing::_internal_has_base() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.base_ != nullptr);
  return value;
}
inline bool CMsgTEBeamRing::has_base() const {
  return _internal_has_base();
}
inline void CMsgTEBeamRing::clear_base() {
  if (_impl_.base_ != nullptr) _impl_.base_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsgTEBaseBeam& CMsgTEBeamRing::_internal_base() const {
  const ::CMsgTEBaseBeam* p = _impl_.base_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgTEBaseBeam&>(
      ::_CMsgTEBaseBeam_default_instance_);
}
inline const ::CMsgTEBaseBeam& CMsgTEBeamRing::base() const {
  // @@protoc_insertion_point(field_get:CMsgTEBeamRing.base)
  return _internal_base();
}
inline void CMsgTEBeamRing::unsafe_arena_set_allocated_base(
    ::CMsgTEBaseBeam* base) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.base_);
  }
  _impl_.base_ = base;
  if (base) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEBeamRing.base)
}
inline ::CMsgTEBaseBeam* CMsgTEBeamRing::release_base() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgTEBaseBeam* temp = _impl_.base_;
  _impl_.base_ = 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 ::CMsgTEBaseBeam* CMsgTEBeamRing::unsafe_arena_release_base() {
  // @@protoc_insertion_point(field_release:CMsgTEBeamRing.base)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgTEBaseBeam* temp = _impl_.base_;
  _impl_.base_ = nullptr;
  return temp;
}
inline ::CMsgTEBaseBeam* CMsgTEBeamRing::_internal_mutable_base() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.base_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgTEBaseBeam>(GetArenaForAllocation());
    _impl_.base_ = p;
  }
  return _impl_.base_;
}
inline ::CMsgTEBaseBeam* CMsgTEBeamRing::mutable_base() {
  ::CMsgTEBaseBeam* _msg = _internal_mutable_base();
  // @@protoc_insertion_point(field_mutable:CMsgTEBeamRing.base)
  return _msg;
}
inline void CMsgTEBeamRing::set_allocated_base(::CMsgTEBaseBeam* base) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.base_;
  }
  if (base) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(base);
    if (message_arena != submessage_arena) {
      base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, base, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.base_ = base;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEBeamRing.base)
}

// optional uint32 startentity = 2;
inline bool CMsgTEBeamRing::_internal_has_startentity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgTEBeamRing::has_startentity() const {
  return _internal_has_startentity();
}
inline void CMsgTEBeamRing::clear_startentity() {
  _impl_.startentity_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgTEBeamRing::_internal_startentity() const {
  return _impl_.startentity_;
}
inline uint32_t CMsgTEBeamRing::startentity() const {
  // @@protoc_insertion_point(field_get:CMsgTEBeamRing.startentity)
  return _internal_startentity();
}
inline void CMsgTEBeamRing::_internal_set_startentity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.startentity_ = value;
}
inline void CMsgTEBeamRing::set_startentity(uint32_t value) {
  _internal_set_startentity(value);
  // @@protoc_insertion_point(field_set:CMsgTEBeamRing.startentity)
}

// optional uint32 endentity = 3;
inline bool CMsgTEBeamRing::_internal_has_endentity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgTEBeamRing::has_endentity() const {
  return _internal_has_endentity();
}
inline void CMsgTEBeamRing::clear_endentity() {
  _impl_.endentity_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgTEBeamRing::_internal_endentity() const {
  return _impl_.endentity_;
}
inline uint32_t CMsgTEBeamRing::endentity() const {
  // @@protoc_insertion_point(field_get:CMsgTEBeamRing.endentity)
  return _internal_endentity();
}
inline void CMsgTEBeamRing::_internal_set_endentity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.endentity_ = value;
}
inline void CMsgTEBeamRing::set_endentity(uint32_t value) {
  _internal_set_endentity(value);
  // @@protoc_insertion_point(field_set:CMsgTEBeamRing.endentity)
}

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

// CMsgTEBubbles

// optional .CMsgVector mins = 1;
inline bool CMsgTEBubbles::_internal_has_mins() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.mins_ != nullptr);
  return value;
}
inline bool CMsgTEBubbles::has_mins() const {
  return _internal_has_mins();
}
inline const ::CMsgVector& CMsgTEBubbles::_internal_mins() const {
  const ::CMsgVector* p = _impl_.mins_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEBubbles::mins() const {
  // @@protoc_insertion_point(field_get:CMsgTEBubbles.mins)
  return _internal_mins();
}
inline void CMsgTEBubbles::unsafe_arena_set_allocated_mins(
    ::CMsgVector* mins) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mins_);
  }
  _impl_.mins_ = mins;
  if (mins) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEBubbles.mins)
}
inline ::CMsgVector* CMsgTEBubbles::release_mins() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.mins_;
  _impl_.mins_ = 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* CMsgTEBubbles::unsafe_arena_release_mins() {
  // @@protoc_insertion_point(field_release:CMsgTEBubbles.mins)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.mins_;
  _impl_.mins_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEBubbles::_internal_mutable_mins() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.mins_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.mins_ = p;
  }
  return _impl_.mins_;
}
inline ::CMsgVector* CMsgTEBubbles::mutable_mins() {
  ::CMsgVector* _msg = _internal_mutable_mins();
  // @@protoc_insertion_point(field_mutable:CMsgTEBubbles.mins)
  return _msg;
}
inline void CMsgTEBubbles::set_allocated_mins(::CMsgVector* mins) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mins_);
  }
  if (mins) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(mins));
    if (message_arena != submessage_arena) {
      mins = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, mins, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.mins_ = mins;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEBubbles.mins)
}

// optional .CMsgVector maxs = 2;
inline bool CMsgTEBubbles::_internal_has_maxs() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.maxs_ != nullptr);
  return value;
}
inline bool CMsgTEBubbles::has_maxs() const {
  return _internal_has_maxs();
}
inline const ::CMsgVector& CMsgTEBubbles::_internal_maxs() const {
  const ::CMsgVector* p = _impl_.maxs_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEBubbles::maxs() const {
  // @@protoc_insertion_point(field_get:CMsgTEBubbles.maxs)
  return _internal_maxs();
}
inline void CMsgTEBubbles::unsafe_arena_set_allocated_maxs(
    ::CMsgVector* maxs) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.maxs_);
  }
  _impl_.maxs_ = maxs;
  if (maxs) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEBubbles.maxs)
}
inline ::CMsgVector* CMsgTEBubbles::release_maxs() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.maxs_;
  _impl_.maxs_ = 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* CMsgTEBubbles::unsafe_arena_release_maxs() {
  // @@protoc_insertion_point(field_release:CMsgTEBubbles.maxs)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.maxs_;
  _impl_.maxs_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEBubbles::_internal_mutable_maxs() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.maxs_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.maxs_ = p;
  }
  return _impl_.maxs_;
}
inline ::CMsgVector* CMsgTEBubbles::mutable_maxs() {
  ::CMsgVector* _msg = _internal_mutable_maxs();
  // @@protoc_insertion_point(field_mutable:CMsgTEBubbles.maxs)
  return _msg;
}
inline void CMsgTEBubbles::set_allocated_maxs(::CMsgVector* maxs) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.maxs_);
  }
  if (maxs) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(maxs));
    if (message_arena != submessage_arena) {
      maxs = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, maxs, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.maxs_ = maxs;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEBubbles.maxs)
}

// optional float height = 3;
inline bool CMsgTEBubbles::_internal_has_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgTEBubbles::has_height() const {
  return _internal_has_height();
}
inline void CMsgTEBubbles::clear_height() {
  _impl_.height_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CMsgTEBubbles::_internal_height() const {
  return _impl_.height_;
}
inline float CMsgTEBubbles::height() const {
  // @@protoc_insertion_point(field_get:CMsgTEBubbles.height)
  return _internal_height();
}
inline void CMsgTEBubbles::_internal_set_height(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.height_ = value;
}
inline void CMsgTEBubbles::set_height(float value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:CMsgTEBubbles.height)
}

// optional uint32 count = 4;
inline bool CMsgTEBubbles::_internal_has_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgTEBubbles::has_count() const {
  return _internal_has_count();
}
inline void CMsgTEBubbles::clear_count() {
  _impl_.count_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgTEBubbles::_internal_count() const {
  return _impl_.count_;
}
inline uint32_t CMsgTEBubbles::count() const {
  // @@protoc_insertion_point(field_get:CMsgTEBubbles.count)
  return _internal_count();
}
inline void CMsgTEBubbles::_internal_set_count(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.count_ = value;
}
inline void CMsgTEBubbles::set_count(uint32_t value) {
  _internal_set_count(value);
  // @@protoc_insertion_point(field_set:CMsgTEBubbles.count)
}

// optional float speed = 5;
inline bool CMsgTEBubbles::_internal_has_speed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgTEBubbles::has_speed() const {
  return _internal_has_speed();
}
inline void CMsgTEBubbles::clear_speed() {
  _impl_.speed_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float CMsgTEBubbles::_internal_speed() const {
  return _impl_.speed_;
}
inline float CMsgTEBubbles::speed() const {
  // @@protoc_insertion_point(field_get:CMsgTEBubbles.speed)
  return _internal_speed();
}
inline void CMsgTEBubbles::_internal_set_speed(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.speed_ = value;
}
inline void CMsgTEBubbles::set_speed(float value) {
  _internal_set_speed(value);
  // @@protoc_insertion_point(field_set:CMsgTEBubbles.speed)
}

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

// CMsgTEBubbleTrail

// optional .CMsgVector mins = 1;
inline bool CMsgTEBubbleTrail::_internal_has_mins() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.mins_ != nullptr);
  return value;
}
inline bool CMsgTEBubbleTrail::has_mins() const {
  return _internal_has_mins();
}
inline const ::CMsgVector& CMsgTEBubbleTrail::_internal_mins() const {
  const ::CMsgVector* p = _impl_.mins_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEBubbleTrail::mins() const {
  // @@protoc_insertion_point(field_get:CMsgTEBubbleTrail.mins)
  return _internal_mins();
}
inline void CMsgTEBubbleTrail::unsafe_arena_set_allocated_mins(
    ::CMsgVector* mins) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mins_);
  }
  _impl_.mins_ = mins;
  if (mins) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEBubbleTrail.mins)
}
inline ::CMsgVector* CMsgTEBubbleTrail::release_mins() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.mins_;
  _impl_.mins_ = 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* CMsgTEBubbleTrail::unsafe_arena_release_mins() {
  // @@protoc_insertion_point(field_release:CMsgTEBubbleTrail.mins)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.mins_;
  _impl_.mins_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEBubbleTrail::_internal_mutable_mins() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.mins_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.mins_ = p;
  }
  return _impl_.mins_;
}
inline ::CMsgVector* CMsgTEBubbleTrail::mutable_mins() {
  ::CMsgVector* _msg = _internal_mutable_mins();
  // @@protoc_insertion_point(field_mutable:CMsgTEBubbleTrail.mins)
  return _msg;
}
inline void CMsgTEBubbleTrail::set_allocated_mins(::CMsgVector* mins) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mins_);
  }
  if (mins) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(mins));
    if (message_arena != submessage_arena) {
      mins = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, mins, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.mins_ = mins;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEBubbleTrail.mins)
}

// optional .CMsgVector maxs = 2;
inline bool CMsgTEBubbleTrail::_internal_has_maxs() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.maxs_ != nullptr);
  return value;
}
inline bool CMsgTEBubbleTrail::has_maxs() const {
  return _internal_has_maxs();
}
inline const ::CMsgVector& CMsgTEBubbleTrail::_internal_maxs() const {
  const ::CMsgVector* p = _impl_.maxs_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEBubbleTrail::maxs() const {
  // @@protoc_insertion_point(field_get:CMsgTEBubbleTrail.maxs)
  return _internal_maxs();
}
inline void CMsgTEBubbleTrail::unsafe_arena_set_allocated_maxs(
    ::CMsgVector* maxs) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.maxs_);
  }
  _impl_.maxs_ = maxs;
  if (maxs) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEBubbleTrail.maxs)
}
inline ::CMsgVector* CMsgTEBubbleTrail::release_maxs() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.maxs_;
  _impl_.maxs_ = 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* CMsgTEBubbleTrail::unsafe_arena_release_maxs() {
  // @@protoc_insertion_point(field_release:CMsgTEBubbleTrail.maxs)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.maxs_;
  _impl_.maxs_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEBubbleTrail::_internal_mutable_maxs() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.maxs_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.maxs_ = p;
  }
  return _impl_.maxs_;
}
inline ::CMsgVector* CMsgTEBubbleTrail::mutable_maxs() {
  ::CMsgVector* _msg = _internal_mutable_maxs();
  // @@protoc_insertion_point(field_mutable:CMsgTEBubbleTrail.maxs)
  return _msg;
}
inline void CMsgTEBubbleTrail::set_allocated_maxs(::CMsgVector* maxs) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.maxs_);
  }
  if (maxs) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(maxs));
    if (message_arena != submessage_arena) {
      maxs = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, maxs, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.maxs_ = maxs;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEBubbleTrail.maxs)
}

// optional float waterz = 3;
inline bool CMsgTEBubbleTrail::_internal_has_waterz() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgTEBubbleTrail::has_waterz() const {
  return _internal_has_waterz();
}
inline void CMsgTEBubbleTrail::clear_waterz() {
  _impl_.waterz_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CMsgTEBubbleTrail::_internal_waterz() const {
  return _impl_.waterz_;
}
inline float CMsgTEBubbleTrail::waterz() const {
  // @@protoc_insertion_point(field_get:CMsgTEBubbleTrail.waterz)
  return _internal_waterz();
}
inline void CMsgTEBubbleTrail::_internal_set_waterz(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.waterz_ = value;
}
inline void CMsgTEBubbleTrail::set_waterz(float value) {
  _internal_set_waterz(value);
  // @@protoc_insertion_point(field_set:CMsgTEBubbleTrail.waterz)
}

// optional uint32 count = 4;
inline bool CMsgTEBubbleTrail::_internal_has_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgTEBubbleTrail::has_count() const {
  return _internal_has_count();
}
inline void CMsgTEBubbleTrail::clear_count() {
  _impl_.count_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgTEBubbleTrail::_internal_count() const {
  return _impl_.count_;
}
inline uint32_t CMsgTEBubbleTrail::count() const {
  // @@protoc_insertion_point(field_get:CMsgTEBubbleTrail.count)
  return _internal_count();
}
inline void CMsgTEBubbleTrail::_internal_set_count(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.count_ = value;
}
inline void CMsgTEBubbleTrail::set_count(uint32_t value) {
  _internal_set_count(value);
  // @@protoc_insertion_point(field_set:CMsgTEBubbleTrail.count)
}

// optional float speed = 5;
inline bool CMsgTEBubbleTrail::_internal_has_speed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgTEBubbleTrail::has_speed() const {
  return _internal_has_speed();
}
inline void CMsgTEBubbleTrail::clear_speed() {
  _impl_.speed_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float CMsgTEBubbleTrail::_internal_speed() const {
  return _impl_.speed_;
}
inline float CMsgTEBubbleTrail::speed() const {
  // @@protoc_insertion_point(field_get:CMsgTEBubbleTrail.speed)
  return _internal_speed();
}
inline void CMsgTEBubbleTrail::_internal_set_speed(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.speed_ = value;
}
inline void CMsgTEBubbleTrail::set_speed(float value) {
  _internal_set_speed(value);
  // @@protoc_insertion_point(field_set:CMsgTEBubbleTrail.speed)
}

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

// CMsgTEDecal

// optional .CMsgVector origin = 1;
inline bool CMsgTEDecal::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CMsgTEDecal::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CMsgTEDecal::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEDecal::origin() const {
  // @@protoc_insertion_point(field_get:CMsgTEDecal.origin)
  return _internal_origin();
}
inline void CMsgTEDecal::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEDecal.origin)
}
inline ::CMsgVector* CMsgTEDecal::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTEDecal::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CMsgTEDecal.origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEDecal::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CMsgTEDecal::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CMsgTEDecal.origin)
  return _msg;
}
inline void CMsgTEDecal::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEDecal.origin)
}

// optional .CMsgVector start = 2;
inline bool CMsgTEDecal::_internal_has_start() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.start_ != nullptr);
  return value;
}
inline bool CMsgTEDecal::has_start() const {
  return _internal_has_start();
}
inline const ::CMsgVector& CMsgTEDecal::_internal_start() const {
  const ::CMsgVector* p = _impl_.start_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEDecal::start() const {
  // @@protoc_insertion_point(field_get:CMsgTEDecal.start)
  return _internal_start();
}
inline void CMsgTEDecal::unsafe_arena_set_allocated_start(
    ::CMsgVector* start) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_);
  }
  _impl_.start_ = start;
  if (start) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEDecal.start)
}
inline ::CMsgVector* CMsgTEDecal::release_start() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.start_;
  _impl_.start_ = 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* CMsgTEDecal::unsafe_arena_release_start() {
  // @@protoc_insertion_point(field_release:CMsgTEDecal.start)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.start_;
  _impl_.start_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEDecal::_internal_mutable_start() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.start_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.start_ = p;
  }
  return _impl_.start_;
}
inline ::CMsgVector* CMsgTEDecal::mutable_start() {
  ::CMsgVector* _msg = _internal_mutable_start();
  // @@protoc_insertion_point(field_mutable:CMsgTEDecal.start)
  return _msg;
}
inline void CMsgTEDecal::set_allocated_start(::CMsgVector* start) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_);
  }
  if (start) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(start));
    if (message_arena != submessage_arena) {
      start = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, start, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.start_ = start;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEDecal.start)
}

// optional int32 entity = 3 [default = -1];
inline bool CMsgTEDecal::_internal_has_entity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgTEDecal::has_entity() const {
  return _internal_has_entity();
}
inline void CMsgTEDecal::clear_entity() {
  _impl_.entity_ = -1;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CMsgTEDecal::_internal_entity() const {
  return _impl_.entity_;
}
inline int32_t CMsgTEDecal::entity() const {
  // @@protoc_insertion_point(field_get:CMsgTEDecal.entity)
  return _internal_entity();
}
inline void CMsgTEDecal::_internal_set_entity(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.entity_ = value;
}
inline void CMsgTEDecal::set_entity(int32_t value) {
  _internal_set_entity(value);
  // @@protoc_insertion_point(field_set:CMsgTEDecal.entity)
}

// optional uint32 hitbox = 4;
inline bool CMsgTEDecal::_internal_has_hitbox() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgTEDecal::has_hitbox() const {
  return _internal_has_hitbox();
}
inline void CMsgTEDecal::clear_hitbox() {
  _impl_.hitbox_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgTEDecal::_internal_hitbox() const {
  return _impl_.hitbox_;
}
inline uint32_t CMsgTEDecal::hitbox() const {
  // @@protoc_insertion_point(field_get:CMsgTEDecal.hitbox)
  return _internal_hitbox();
}
inline void CMsgTEDecal::_internal_set_hitbox(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.hitbox_ = value;
}
inline void CMsgTEDecal::set_hitbox(uint32_t value) {
  _internal_set_hitbox(value);
  // @@protoc_insertion_point(field_set:CMsgTEDecal.hitbox)
}

// optional uint32 index = 5;
inline bool CMsgTEDecal::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgTEDecal::has_index() const {
  return _internal_has_index();
}
inline void CMsgTEDecal::clear_index() {
  _impl_.index_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgTEDecal::_internal_index() const {
  return _impl_.index_;
}
inline uint32_t CMsgTEDecal::index() const {
  // @@protoc_insertion_point(field_get:CMsgTEDecal.index)
  return _internal_index();
}
inline void CMsgTEDecal::_internal_set_index(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.index_ = value;
}
inline void CMsgTEDecal::set_index(uint32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:CMsgTEDecal.index)
}

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

// CMsgEffectData

// optional .CMsgVector origin = 1;
inline bool CMsgEffectData::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CMsgEffectData::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CMsgEffectData::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgEffectData::origin() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.origin)
  return _internal_origin();
}
inline void CMsgEffectData::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgEffectData.origin)
}
inline ::CMsgVector* CMsgEffectData::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgEffectData::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CMsgEffectData.origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgEffectData::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CMsgEffectData::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CMsgEffectData.origin)
  return _msg;
}
inline void CMsgEffectData::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CMsgEffectData.origin)
}

// optional .CMsgVector start = 2;
inline bool CMsgEffectData::_internal_has_start() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.start_ != nullptr);
  return value;
}
inline bool CMsgEffectData::has_start() const {
  return _internal_has_start();
}
inline const ::CMsgVector& CMsgEffectData::_internal_start() const {
  const ::CMsgVector* p = _impl_.start_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgEffectData::start() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.start)
  return _internal_start();
}
inline void CMsgEffectData::unsafe_arena_set_allocated_start(
    ::CMsgVector* start) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_);
  }
  _impl_.start_ = start;
  if (start) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgEffectData.start)
}
inline ::CMsgVector* CMsgEffectData::release_start() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.start_;
  _impl_.start_ = 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* CMsgEffectData::unsafe_arena_release_start() {
  // @@protoc_insertion_point(field_release:CMsgEffectData.start)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.start_;
  _impl_.start_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgEffectData::_internal_mutable_start() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.start_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.start_ = p;
  }
  return _impl_.start_;
}
inline ::CMsgVector* CMsgEffectData::mutable_start() {
  ::CMsgVector* _msg = _internal_mutable_start();
  // @@protoc_insertion_point(field_mutable:CMsgEffectData.start)
  return _msg;
}
inline void CMsgEffectData::set_allocated_start(::CMsgVector* start) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.start_);
  }
  if (start) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(start));
    if (message_arena != submessage_arena) {
      start = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, start, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.start_ = start;
  // @@protoc_insertion_point(field_set_allocated:CMsgEffectData.start)
}

// optional .CMsgVector normal = 3;
inline bool CMsgEffectData::_internal_has_normal() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.normal_ != nullptr);
  return value;
}
inline bool CMsgEffectData::has_normal() const {
  return _internal_has_normal();
}
inline const ::CMsgVector& CMsgEffectData::_internal_normal() const {
  const ::CMsgVector* p = _impl_.normal_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgEffectData::normal() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.normal)
  return _internal_normal();
}
inline void CMsgEffectData::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] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgEffectData.normal)
}
inline ::CMsgVector* CMsgEffectData::release_normal() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::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* CMsgEffectData::unsafe_arena_release_normal() {
  // @@protoc_insertion_point(field_release:CMsgEffectData.normal)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.normal_;
  _impl_.normal_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgEffectData::_internal_mutable_normal() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.normal_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.normal_ = p;
  }
  return _impl_.normal_;
}
inline ::CMsgVector* CMsgEffectData::mutable_normal() {
  ::CMsgVector* _msg = _internal_mutable_normal();
  // @@protoc_insertion_point(field_mutable:CMsgEffectData.normal)
  return _msg;
}
inline void CMsgEffectData::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] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.normal_ = normal;
  // @@protoc_insertion_point(field_set_allocated:CMsgEffectData.normal)
}

// optional .CMsgQAngle angles = 4;
inline bool CMsgEffectData::_internal_has_angles() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.angles_ != nullptr);
  return value;
}
inline bool CMsgEffectData::has_angles() const {
  return _internal_has_angles();
}
inline const ::CMsgQAngle& CMsgEffectData::_internal_angles() const {
  const ::CMsgQAngle* p = _impl_.angles_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQAngle&>(
      ::_CMsgQAngle_default_instance_);
}
inline const ::CMsgQAngle& CMsgEffectData::angles() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.angles)
  return _internal_angles();
}
inline void CMsgEffectData::unsafe_arena_set_allocated_angles(
    ::CMsgQAngle* angles) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angles_);
  }
  _impl_.angles_ = angles;
  if (angles) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgEffectData.angles)
}
inline ::CMsgQAngle* CMsgEffectData::release_angles() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgQAngle* temp = _impl_.angles_;
  _impl_.angles_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgQAngle* CMsgEffectData::unsafe_arena_release_angles() {
  // @@protoc_insertion_point(field_release:CMsgEffectData.angles)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgQAngle* temp = _impl_.angles_;
  _impl_.angles_ = nullptr;
  return temp;
}
inline ::CMsgQAngle* CMsgEffectData::_internal_mutable_angles() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.angles_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgQAngle>(GetArenaForAllocation());
    _impl_.angles_ = p;
  }
  return _impl_.angles_;
}
inline ::CMsgQAngle* CMsgEffectData::mutable_angles() {
  ::CMsgQAngle* _msg = _internal_mutable_angles();
  // @@protoc_insertion_point(field_mutable:CMsgEffectData.angles)
  return _msg;
}
inline void CMsgEffectData::set_allocated_angles(::CMsgQAngle* angles) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angles_);
  }
  if (angles) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(angles));
    if (message_arena != submessage_arena) {
      angles = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, angles, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.angles_ = angles;
  // @@protoc_insertion_point(field_set_allocated:CMsgEffectData.angles)
}

// optional fixed32 entity = 5 [default = 16777215];
inline bool CMsgEffectData::_internal_has_entity() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool CMsgEffectData::has_entity() const {
  return _internal_has_entity();
}
inline void CMsgEffectData::clear_entity() {
  _impl_.entity_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline uint32_t CMsgEffectData::_internal_entity() const {
  return _impl_.entity_;
}
inline uint32_t CMsgEffectData::entity() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.entity)
  return _internal_entity();
}
inline void CMsgEffectData::_internal_set_entity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.entity_ = value;
}
inline void CMsgEffectData::set_entity(uint32_t value) {
  _internal_set_entity(value);
  // @@protoc_insertion_point(field_set:CMsgEffectData.entity)
}

// optional fixed32 otherentity = 6 [default = 16777215];
inline bool CMsgEffectData::_internal_has_otherentity() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool CMsgEffectData::has_otherentity() const {
  return _internal_has_otherentity();
}
inline void CMsgEffectData::clear_otherentity() {
  _impl_.otherentity_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline uint32_t CMsgEffectData::_internal_otherentity() const {
  return _impl_.otherentity_;
}
inline uint32_t CMsgEffectData::otherentity() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.otherentity)
  return _internal_otherentity();
}
inline void CMsgEffectData::_internal_set_otherentity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.otherentity_ = value;
}
inline void CMsgEffectData::set_otherentity(uint32_t value) {
  _internal_set_otherentity(value);
  // @@protoc_insertion_point(field_set:CMsgEffectData.otherentity)
}

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

// optional float magnitude = 8;
inline bool CMsgEffectData::_internal_has_magnitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgEffectData::has_magnitude() const {
  return _internal_has_magnitude();
}
inline void CMsgEffectData::clear_magnitude() {
  _impl_.magnitude_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float CMsgEffectData::_internal_magnitude() const {
  return _impl_.magnitude_;
}
inline float CMsgEffectData::magnitude() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.magnitude)
  return _internal_magnitude();
}
inline void CMsgEffectData::_internal_set_magnitude(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.magnitude_ = value;
}
inline void CMsgEffectData::set_magnitude(float value) {
  _internal_set_magnitude(value);
  // @@protoc_insertion_point(field_set:CMsgEffectData.magnitude)
}

// optional float radius = 9;
inline bool CMsgEffectData::_internal_has_radius() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgEffectData::has_radius() const {
  return _internal_has_radius();
}
inline void CMsgEffectData::clear_radius() {
  _impl_.radius_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float CMsgEffectData::_internal_radius() const {
  return _impl_.radius_;
}
inline float CMsgEffectData::radius() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.radius)
  return _internal_radius();
}
inline void CMsgEffectData::_internal_set_radius(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.radius_ = value;
}
inline void CMsgEffectData::set_radius(float value) {
  _internal_set_radius(value);
  // @@protoc_insertion_point(field_set:CMsgEffectData.radius)
}

// optional fixed32 surfaceprop = 10;
inline bool CMsgEffectData::_internal_has_surfaceprop() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgEffectData::has_surfaceprop() const {
  return _internal_has_surfaceprop();
}
inline void CMsgEffectData::clear_surfaceprop() {
  _impl_.surfaceprop_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgEffectData::_internal_surfaceprop() const {
  return _impl_.surfaceprop_;
}
inline uint32_t CMsgEffectData::surfaceprop() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.surfaceprop)
  return _internal_surfaceprop();
}
inline void CMsgEffectData::_internal_set_surfaceprop(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.surfaceprop_ = value;
}
inline void CMsgEffectData::set_surfaceprop(uint32_t value) {
  _internal_set_surfaceprop(value);
  // @@protoc_insertion_point(field_set:CMsgEffectData.surfaceprop)
}

// optional fixed64 effectindex = 11;
inline bool CMsgEffectData::_internal_has_effectindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgEffectData::has_effectindex() const {
  return _internal_has_effectindex();
}
inline void CMsgEffectData::clear_effectindex() {
  _impl_.effectindex_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint64_t CMsgEffectData::_internal_effectindex() const {
  return _impl_.effectindex_;
}
inline uint64_t CMsgEffectData::effectindex() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.effectindex)
  return _internal_effectindex();
}
inline void CMsgEffectData::_internal_set_effectindex(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.effectindex_ = value;
}
inline void CMsgEffectData::set_effectindex(uint64_t value) {
  _internal_set_effectindex(value);
  // @@protoc_insertion_point(field_set:CMsgEffectData.effectindex)
}

// optional uint32 damagetype = 12;
inline bool CMsgEffectData::_internal_has_damagetype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgEffectData::has_damagetype() const {
  return _internal_has_damagetype();
}
inline void CMsgEffectData::clear_damagetype() {
  _impl_.damagetype_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t CMsgEffectData::_internal_damagetype() const {
  return _impl_.damagetype_;
}
inline uint32_t CMsgEffectData::damagetype() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.damagetype)
  return _internal_damagetype();
}
inline void CMsgEffectData::_internal_set_damagetype(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.damagetype_ = value;
}
inline void CMsgEffectData::set_damagetype(uint32_t value) {
  _internal_set_damagetype(value);
  // @@protoc_insertion_point(field_set:CMsgEffectData.damagetype)
}

// optional uint32 material = 13;
inline bool CMsgEffectData::_internal_has_material() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgEffectData::has_material() const {
  return _internal_has_material();
}
inline void CMsgEffectData::clear_material() {
  _impl_.material_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CMsgEffectData::_internal_material() const {
  return _impl_.material_;
}
inline uint32_t CMsgEffectData::material() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.material)
  return _internal_material();
}
inline void CMsgEffectData::_internal_set_material(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.material_ = value;
}
inline void CMsgEffectData::set_material(uint32_t value) {
  _internal_set_material(value);
  // @@protoc_insertion_point(field_set:CMsgEffectData.material)
}

// optional uint32 hitbox = 14;
inline bool CMsgEffectData::_internal_has_hitbox() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CMsgEffectData::has_hitbox() const {
  return _internal_has_hitbox();
}
inline void CMsgEffectData::clear_hitbox() {
  _impl_.hitbox_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t CMsgEffectData::_internal_hitbox() const {
  return _impl_.hitbox_;
}
inline uint32_t CMsgEffectData::hitbox() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.hitbox)
  return _internal_hitbox();
}
inline void CMsgEffectData::_internal_set_hitbox(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.hitbox_ = value;
}
inline void CMsgEffectData::set_hitbox(uint32_t value) {
  _internal_set_hitbox(value);
  // @@protoc_insertion_point(field_set:CMsgEffectData.hitbox)
}

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

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

// optional int32 attachmentindex = 17;
inline bool CMsgEffectData::_internal_has_attachmentindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CMsgEffectData::has_attachmentindex() const {
  return _internal_has_attachmentindex();
}
inline void CMsgEffectData::clear_attachmentindex() {
  _impl_.attachmentindex_ = 0;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline int32_t CMsgEffectData::_internal_attachmentindex() const {
  return _impl_.attachmentindex_;
}
inline int32_t CMsgEffectData::attachmentindex() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.attachmentindex)
  return _internal_attachmentindex();
}
inline void CMsgEffectData::_internal_set_attachmentindex(int32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.attachmentindex_ = value;
}
inline void CMsgEffectData::set_attachmentindex(int32_t value) {
  _internal_set_attachmentindex(value);
  // @@protoc_insertion_point(field_set:CMsgEffectData.attachmentindex)
}

// optional uint32 effectname = 18;
inline bool CMsgEffectData::_internal_has_effectname() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool CMsgEffectData::has_effectname() const {
  return _internal_has_effectname();
}
inline void CMsgEffectData::clear_effectname() {
  _impl_.effectname_ = 0u;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline uint32_t CMsgEffectData::_internal_effectname() const {
  return _impl_.effectname_;
}
inline uint32_t CMsgEffectData::effectname() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.effectname)
  return _internal_effectname();
}
inline void CMsgEffectData::_internal_set_effectname(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.effectname_ = value;
}
inline void CMsgEffectData::set_effectname(uint32_t value) {
  _internal_set_effectname(value);
  // @@protoc_insertion_point(field_set:CMsgEffectData.effectname)
}

// optional uint32 attachmentname = 19;
inline bool CMsgEffectData::_internal_has_attachmentname() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool CMsgEffectData::has_attachmentname() const {
  return _internal_has_attachmentname();
}
inline void CMsgEffectData::clear_attachmentname() {
  _impl_.attachmentname_ = 0u;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline uint32_t CMsgEffectData::_internal_attachmentname() const {
  return _impl_.attachmentname_;
}
inline uint32_t CMsgEffectData::attachmentname() const {
  // @@protoc_insertion_point(field_get:CMsgEffectData.attachmentname)
  return _internal_attachmentname();
}
inline void CMsgEffectData::_internal_set_attachmentname(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.attachmentname_ = value;
}
inline void CMsgEffectData::set_attachmentname(uint32_t value) {
  _internal_set_attachmentname(value);
  // @@protoc_insertion_point(field_set:CMsgEffectData.attachmentname)
}

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

// CMsgTEEffectDispatch

// optional .CMsgEffectData effectdata = 1;
inline bool CMsgTEEffectDispatch::_internal_has_effectdata() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.effectdata_ != nullptr);
  return value;
}
inline bool CMsgTEEffectDispatch::has_effectdata() const {
  return _internal_has_effectdata();
}
inline void CMsgTEEffectDispatch::clear_effectdata() {
  if (_impl_.effectdata_ != nullptr) _impl_.effectdata_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsgEffectData& CMsgTEEffectDispatch::_internal_effectdata() const {
  const ::CMsgEffectData* p = _impl_.effectdata_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgEffectData&>(
      ::_CMsgEffectData_default_instance_);
}
inline const ::CMsgEffectData& CMsgTEEffectDispatch::effectdata() const {
  // @@protoc_insertion_point(field_get:CMsgTEEffectDispatch.effectdata)
  return _internal_effectdata();
}
inline void CMsgTEEffectDispatch::unsafe_arena_set_allocated_effectdata(
    ::CMsgEffectData* effectdata) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.effectdata_);
  }
  _impl_.effectdata_ = effectdata;
  if (effectdata) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEEffectDispatch.effectdata)
}
inline ::CMsgEffectData* CMsgTEEffectDispatch::release_effectdata() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgEffectData* temp = _impl_.effectdata_;
  _impl_.effectdata_ = 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 ::CMsgEffectData* CMsgTEEffectDispatch::unsafe_arena_release_effectdata() {
  // @@protoc_insertion_point(field_release:CMsgTEEffectDispatch.effectdata)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgEffectData* temp = _impl_.effectdata_;
  _impl_.effectdata_ = nullptr;
  return temp;
}
inline ::CMsgEffectData* CMsgTEEffectDispatch::_internal_mutable_effectdata() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.effectdata_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgEffectData>(GetArenaForAllocation());
    _impl_.effectdata_ = p;
  }
  return _impl_.effectdata_;
}
inline ::CMsgEffectData* CMsgTEEffectDispatch::mutable_effectdata() {
  ::CMsgEffectData* _msg = _internal_mutable_effectdata();
  // @@protoc_insertion_point(field_mutable:CMsgTEEffectDispatch.effectdata)
  return _msg;
}
inline void CMsgTEEffectDispatch::set_allocated_effectdata(::CMsgEffectData* effectdata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.effectdata_;
  }
  if (effectdata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(effectdata);
    if (message_arena != submessage_arena) {
      effectdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, effectdata, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.effectdata_ = effectdata;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEEffectDispatch.effectdata)
}

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

// CMsgTEEnergySplash

// optional .CMsgVector pos = 1;
inline bool CMsgTEEnergySplash::_internal_has_pos() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pos_ != nullptr);
  return value;
}
inline bool CMsgTEEnergySplash::has_pos() const {
  return _internal_has_pos();
}
inline const ::CMsgVector& CMsgTEEnergySplash::_internal_pos() const {
  const ::CMsgVector* p = _impl_.pos_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEEnergySplash::pos() const {
  // @@protoc_insertion_point(field_get:CMsgTEEnergySplash.pos)
  return _internal_pos();
}
inline void CMsgTEEnergySplash::unsafe_arena_set_allocated_pos(
    ::CMsgVector* pos) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pos_);
  }
  _impl_.pos_ = pos;
  if (pos) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEEnergySplash.pos)
}
inline ::CMsgVector* CMsgTEEnergySplash::release_pos() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.pos_;
  _impl_.pos_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTEEnergySplash::unsafe_arena_release_pos() {
  // @@protoc_insertion_point(field_release:CMsgTEEnergySplash.pos)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.pos_;
  _impl_.pos_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEEnergySplash::_internal_mutable_pos() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.pos_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.pos_ = p;
  }
  return _impl_.pos_;
}
inline ::CMsgVector* CMsgTEEnergySplash::mutable_pos() {
  ::CMsgVector* _msg = _internal_mutable_pos();
  // @@protoc_insertion_point(field_mutable:CMsgTEEnergySplash.pos)
  return _msg;
}
inline void CMsgTEEnergySplash::set_allocated_pos(::CMsgVector* pos) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pos_);
  }
  if (pos) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(pos));
    if (message_arena != submessage_arena) {
      pos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pos, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.pos_ = pos;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEEnergySplash.pos)
}

// optional .CMsgVector dir = 2;
inline bool CMsgTEEnergySplash::_internal_has_dir() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.dir_ != nullptr);
  return value;
}
inline bool CMsgTEEnergySplash::has_dir() const {
  return _internal_has_dir();
}
inline const ::CMsgVector& CMsgTEEnergySplash::_internal_dir() const {
  const ::CMsgVector* p = _impl_.dir_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEEnergySplash::dir() const {
  // @@protoc_insertion_point(field_get:CMsgTEEnergySplash.dir)
  return _internal_dir();
}
inline void CMsgTEEnergySplash::unsafe_arena_set_allocated_dir(
    ::CMsgVector* dir) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dir_);
  }
  _impl_.dir_ = dir;
  if (dir) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEEnergySplash.dir)
}
inline ::CMsgVector* CMsgTEEnergySplash::release_dir() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.dir_;
  _impl_.dir_ = 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* CMsgTEEnergySplash::unsafe_arena_release_dir() {
  // @@protoc_insertion_point(field_release:CMsgTEEnergySplash.dir)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.dir_;
  _impl_.dir_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEEnergySplash::_internal_mutable_dir() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.dir_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.dir_ = p;
  }
  return _impl_.dir_;
}
inline ::CMsgVector* CMsgTEEnergySplash::mutable_dir() {
  ::CMsgVector* _msg = _internal_mutable_dir();
  // @@protoc_insertion_point(field_mutable:CMsgTEEnergySplash.dir)
  return _msg;
}
inline void CMsgTEEnergySplash::set_allocated_dir(::CMsgVector* dir) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dir_);
  }
  if (dir) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dir));
    if (message_arena != submessage_arena) {
      dir = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dir, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.dir_ = dir;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEEnergySplash.dir)
}

// optional bool explosive = 3;
inline bool CMsgTEEnergySplash::_internal_has_explosive() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgTEEnergySplash::has_explosive() const {
  return _internal_has_explosive();
}
inline void CMsgTEEnergySplash::clear_explosive() {
  _impl_.explosive_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CMsgTEEnergySplash::_internal_explosive() const {
  return _impl_.explosive_;
}
inline bool CMsgTEEnergySplash::explosive() const {
  // @@protoc_insertion_point(field_get:CMsgTEEnergySplash.explosive)
  return _internal_explosive();
}
inline void CMsgTEEnergySplash::_internal_set_explosive(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.explosive_ = value;
}
inline void CMsgTEEnergySplash::set_explosive(bool value) {
  _internal_set_explosive(value);
  // @@protoc_insertion_point(field_set:CMsgTEEnergySplash.explosive)
}

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

// CMsgTEFizz

// optional int32 entity = 1 [default = -1];
inline bool CMsgTEFizz::_internal_has_entity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgTEFizz::has_entity() const {
  return _internal_has_entity();
}
inline void CMsgTEFizz::clear_entity() {
  _impl_.entity_ = -1;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t CMsgTEFizz::_internal_entity() const {
  return _impl_.entity_;
}
inline int32_t CMsgTEFizz::entity() const {
  // @@protoc_insertion_point(field_get:CMsgTEFizz.entity)
  return _internal_entity();
}
inline void CMsgTEFizz::_internal_set_entity(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.entity_ = value;
}
inline void CMsgTEFizz::set_entity(int32_t value) {
  _internal_set_entity(value);
  // @@protoc_insertion_point(field_set:CMsgTEFizz.entity)
}

// optional uint32 density = 2;
inline bool CMsgTEFizz::_internal_has_density() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgTEFizz::has_density() const {
  return _internal_has_density();
}
inline void CMsgTEFizz::clear_density() {
  _impl_.density_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgTEFizz::_internal_density() const {
  return _impl_.density_;
}
inline uint32_t CMsgTEFizz::density() const {
  // @@protoc_insertion_point(field_get:CMsgTEFizz.density)
  return _internal_density();
}
inline void CMsgTEFizz::_internal_set_density(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.density_ = value;
}
inline void CMsgTEFizz::set_density(uint32_t value) {
  _internal_set_density(value);
  // @@protoc_insertion_point(field_set:CMsgTEFizz.density)
}

// optional int32 current = 3;
inline bool CMsgTEFizz::_internal_has_current() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgTEFizz::has_current() const {
  return _internal_has_current();
}
inline void CMsgTEFizz::clear_current() {
  _impl_.current_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t CMsgTEFizz::_internal_current() const {
  return _impl_.current_;
}
inline int32_t CMsgTEFizz::current() const {
  // @@protoc_insertion_point(field_get:CMsgTEFizz.current)
  return _internal_current();
}
inline void CMsgTEFizz::_internal_set_current(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.current_ = value;
}
inline void CMsgTEFizz::set_current(int32_t value) {
  _internal_set_current(value);
  // @@protoc_insertion_point(field_set:CMsgTEFizz.current)
}

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

// CMsgTEShatterSurface

// optional .CMsgVector origin = 1;
inline bool CMsgTEShatterSurface::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CMsgTEShatterSurface::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CMsgTEShatterSurface::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEShatterSurface::origin() const {
  // @@protoc_insertion_point(field_get:CMsgTEShatterSurface.origin)
  return _internal_origin();
}
inline void CMsgTEShatterSurface::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEShatterSurface.origin)
}
inline ::CMsgVector* CMsgTEShatterSurface::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTEShatterSurface::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CMsgTEShatterSurface.origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEShatterSurface::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CMsgTEShatterSurface::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CMsgTEShatterSurface.origin)
  return _msg;
}
inline void CMsgTEShatterSurface::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEShatterSurface.origin)
}

// optional .CMsgQAngle angles = 2;
inline bool CMsgTEShatterSurface::_internal_has_angles() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.angles_ != nullptr);
  return value;
}
inline bool CMsgTEShatterSurface::has_angles() const {
  return _internal_has_angles();
}
inline const ::CMsgQAngle& CMsgTEShatterSurface::_internal_angles() const {
  const ::CMsgQAngle* p = _impl_.angles_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQAngle&>(
      ::_CMsgQAngle_default_instance_);
}
inline const ::CMsgQAngle& CMsgTEShatterSurface::angles() const {
  // @@protoc_insertion_point(field_get:CMsgTEShatterSurface.angles)
  return _internal_angles();
}
inline void CMsgTEShatterSurface::unsafe_arena_set_allocated_angles(
    ::CMsgQAngle* angles) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angles_);
  }
  _impl_.angles_ = angles;
  if (angles) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEShatterSurface.angles)
}
inline ::CMsgQAngle* CMsgTEShatterSurface::release_angles() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgQAngle* temp = _impl_.angles_;
  _impl_.angles_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgQAngle* CMsgTEShatterSurface::unsafe_arena_release_angles() {
  // @@protoc_insertion_point(field_release:CMsgTEShatterSurface.angles)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgQAngle* temp = _impl_.angles_;
  _impl_.angles_ = nullptr;
  return temp;
}
inline ::CMsgQAngle* CMsgTEShatterSurface::_internal_mutable_angles() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.angles_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgQAngle>(GetArenaForAllocation());
    _impl_.angles_ = p;
  }
  return _impl_.angles_;
}
inline ::CMsgQAngle* CMsgTEShatterSurface::mutable_angles() {
  ::CMsgQAngle* _msg = _internal_mutable_angles();
  // @@protoc_insertion_point(field_mutable:CMsgTEShatterSurface.angles)
  return _msg;
}
inline void CMsgTEShatterSurface::set_allocated_angles(::CMsgQAngle* angles) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angles_);
  }
  if (angles) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(angles));
    if (message_arena != submessage_arena) {
      angles = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, angles, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.angles_ = angles;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEShatterSurface.angles)
}

// optional .CMsgVector force = 3;
inline bool CMsgTEShatterSurface::_internal_has_force() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.force_ != nullptr);
  return value;
}
inline bool CMsgTEShatterSurface::has_force() const {
  return _internal_has_force();
}
inline const ::CMsgVector& CMsgTEShatterSurface::_internal_force() const {
  const ::CMsgVector* p = _impl_.force_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEShatterSurface::force() const {
  // @@protoc_insertion_point(field_get:CMsgTEShatterSurface.force)
  return _internal_force();
}
inline void CMsgTEShatterSurface::unsafe_arena_set_allocated_force(
    ::CMsgVector* force) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.force_);
  }
  _impl_.force_ = force;
  if (force) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEShatterSurface.force)
}
inline ::CMsgVector* CMsgTEShatterSurface::release_force() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.force_;
  _impl_.force_ = 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* CMsgTEShatterSurface::unsafe_arena_release_force() {
  // @@protoc_insertion_point(field_release:CMsgTEShatterSurface.force)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.force_;
  _impl_.force_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEShatterSurface::_internal_mutable_force() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.force_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.force_ = p;
  }
  return _impl_.force_;
}
inline ::CMsgVector* CMsgTEShatterSurface::mutable_force() {
  ::CMsgVector* _msg = _internal_mutable_force();
  // @@protoc_insertion_point(field_mutable:CMsgTEShatterSurface.force)
  return _msg;
}
inline void CMsgTEShatterSurface::set_allocated_force(::CMsgVector* force) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.force_);
  }
  if (force) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(force));
    if (message_arena != submessage_arena) {
      force = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, force, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.force_ = force;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEShatterSurface.force)
}

// optional .CMsgVector forcepos = 4;
inline bool CMsgTEShatterSurface::_internal_has_forcepos() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.forcepos_ != nullptr);
  return value;
}
inline bool CMsgTEShatterSurface::has_forcepos() const {
  return _internal_has_forcepos();
}
inline const ::CMsgVector& CMsgTEShatterSurface::_internal_forcepos() const {
  const ::CMsgVector* p = _impl_.forcepos_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEShatterSurface::forcepos() const {
  // @@protoc_insertion_point(field_get:CMsgTEShatterSurface.forcepos)
  return _internal_forcepos();
}
inline void CMsgTEShatterSurface::unsafe_arena_set_allocated_forcepos(
    ::CMsgVector* forcepos) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.forcepos_);
  }
  _impl_.forcepos_ = forcepos;
  if (forcepos) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEShatterSurface.forcepos)
}
inline ::CMsgVector* CMsgTEShatterSurface::release_forcepos() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgVector* temp = _impl_.forcepos_;
  _impl_.forcepos_ = 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* CMsgTEShatterSurface::unsafe_arena_release_forcepos() {
  // @@protoc_insertion_point(field_release:CMsgTEShatterSurface.forcepos)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgVector* temp = _impl_.forcepos_;
  _impl_.forcepos_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEShatterSurface::_internal_mutable_forcepos() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.forcepos_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.forcepos_ = p;
  }
  return _impl_.forcepos_;
}
inline ::CMsgVector* CMsgTEShatterSurface::mutable_forcepos() {
  ::CMsgVector* _msg = _internal_mutable_forcepos();
  // @@protoc_insertion_point(field_mutable:CMsgTEShatterSurface.forcepos)
  return _msg;
}
inline void CMsgTEShatterSurface::set_allocated_forcepos(::CMsgVector* forcepos) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.forcepos_);
  }
  if (forcepos) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(forcepos));
    if (message_arena != submessage_arena) {
      forcepos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, forcepos, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.forcepos_ = forcepos;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEShatterSurface.forcepos)
}

// optional float width = 5;
inline bool CMsgTEShatterSurface::_internal_has_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgTEShatterSurface::has_width() const {
  return _internal_has_width();
}
inline void CMsgTEShatterSurface::clear_width() {
  _impl_.width_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float CMsgTEShatterSurface::_internal_width() const {
  return _impl_.width_;
}
inline float CMsgTEShatterSurface::width() const {
  // @@protoc_insertion_point(field_get:CMsgTEShatterSurface.width)
  return _internal_width();
}
inline void CMsgTEShatterSurface::_internal_set_width(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.width_ = value;
}
inline void CMsgTEShatterSurface::set_width(float value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:CMsgTEShatterSurface.width)
}

// optional float height = 6;
inline bool CMsgTEShatterSurface::_internal_has_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgTEShatterSurface::has_height() const {
  return _internal_has_height();
}
inline void CMsgTEShatterSurface::clear_height() {
  _impl_.height_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float CMsgTEShatterSurface::_internal_height() const {
  return _impl_.height_;
}
inline float CMsgTEShatterSurface::height() const {
  // @@protoc_insertion_point(field_get:CMsgTEShatterSurface.height)
  return _internal_height();
}
inline void CMsgTEShatterSurface::_internal_set_height(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.height_ = value;
}
inline void CMsgTEShatterSurface::set_height(float value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:CMsgTEShatterSurface.height)
}

// optional float shardsize = 7;
inline bool CMsgTEShatterSurface::_internal_has_shardsize() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgTEShatterSurface::has_shardsize() const {
  return _internal_has_shardsize();
}
inline void CMsgTEShatterSurface::clear_shardsize() {
  _impl_.shardsize_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float CMsgTEShatterSurface::_internal_shardsize() const {
  return _impl_.shardsize_;
}
inline float CMsgTEShatterSurface::shardsize() const {
  // @@protoc_insertion_point(field_get:CMsgTEShatterSurface.shardsize)
  return _internal_shardsize();
}
inline void CMsgTEShatterSurface::_internal_set_shardsize(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.shardsize_ = value;
}
inline void CMsgTEShatterSurface::set_shardsize(float value) {
  _internal_set_shardsize(value);
  // @@protoc_insertion_point(field_set:CMsgTEShatterSurface.shardsize)
}

// optional uint32 surfacetype = 8;
inline bool CMsgTEShatterSurface::_internal_has_surfacetype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgTEShatterSurface::has_surfacetype() const {
  return _internal_has_surfacetype();
}
inline void CMsgTEShatterSurface::clear_surfacetype() {
  _impl_.surfacetype_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgTEShatterSurface::_internal_surfacetype() const {
  return _impl_.surfacetype_;
}
inline uint32_t CMsgTEShatterSurface::surfacetype() const {
  // @@protoc_insertion_point(field_get:CMsgTEShatterSurface.surfacetype)
  return _internal_surfacetype();
}
inline void CMsgTEShatterSurface::_internal_set_surfacetype(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.surfacetype_ = value;
}
inline void CMsgTEShatterSurface::set_surfacetype(uint32_t value) {
  _internal_set_surfacetype(value);
  // @@protoc_insertion_point(field_set:CMsgTEShatterSurface.surfacetype)
}

// optional fixed32 frontcolor = 9;
inline bool CMsgTEShatterSurface::_internal_has_frontcolor() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgTEShatterSurface::has_frontcolor() const {
  return _internal_has_frontcolor();
}
inline void CMsgTEShatterSurface::clear_frontcolor() {
  _impl_.frontcolor_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t CMsgTEShatterSurface::_internal_frontcolor() const {
  return _impl_.frontcolor_;
}
inline uint32_t CMsgTEShatterSurface::frontcolor() const {
  // @@protoc_insertion_point(field_get:CMsgTEShatterSurface.frontcolor)
  return _internal_frontcolor();
}
inline void CMsgTEShatterSurface::_internal_set_frontcolor(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.frontcolor_ = value;
}
inline void CMsgTEShatterSurface::set_frontcolor(uint32_t value) {
  _internal_set_frontcolor(value);
  // @@protoc_insertion_point(field_set:CMsgTEShatterSurface.frontcolor)
}

// optional fixed32 backcolor = 10;
inline bool CMsgTEShatterSurface::_internal_has_backcolor() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgTEShatterSurface::has_backcolor() const {
  return _internal_has_backcolor();
}
inline void CMsgTEShatterSurface::clear_backcolor() {
  _impl_.backcolor_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t CMsgTEShatterSurface::_internal_backcolor() const {
  return _impl_.backcolor_;
}
inline uint32_t CMsgTEShatterSurface::backcolor() const {
  // @@protoc_insertion_point(field_get:CMsgTEShatterSurface.backcolor)
  return _internal_backcolor();
}
inline void CMsgTEShatterSurface::_internal_set_backcolor(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.backcolor_ = value;
}
inline void CMsgTEShatterSurface::set_backcolor(uint32_t value) {
  _internal_set_backcolor(value);
  // @@protoc_insertion_point(field_set:CMsgTEShatterSurface.backcolor)
}

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

// CMsgTEGlowSprite

// optional .CMsgVector origin = 1;
inline bool CMsgTEGlowSprite::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CMsgTEGlowSprite::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CMsgTEGlowSprite::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEGlowSprite::origin() const {
  // @@protoc_insertion_point(field_get:CMsgTEGlowSprite.origin)
  return _internal_origin();
}
inline void CMsgTEGlowSprite::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEGlowSprite.origin)
}
inline ::CMsgVector* CMsgTEGlowSprite::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTEGlowSprite::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CMsgTEGlowSprite.origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEGlowSprite::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CMsgTEGlowSprite::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CMsgTEGlowSprite.origin)
  return _msg;
}
inline void CMsgTEGlowSprite::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEGlowSprite.origin)
}

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

// optional float life = 3;
inline bool CMsgTEGlowSprite::_internal_has_life() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgTEGlowSprite::has_life() const {
  return _internal_has_life();
}
inline void CMsgTEGlowSprite::clear_life() {
  _impl_.life_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CMsgTEGlowSprite::_internal_life() const {
  return _impl_.life_;
}
inline float CMsgTEGlowSprite::life() const {
  // @@protoc_insertion_point(field_get:CMsgTEGlowSprite.life)
  return _internal_life();
}
inline void CMsgTEGlowSprite::_internal_set_life(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.life_ = value;
}
inline void CMsgTEGlowSprite::set_life(float value) {
  _internal_set_life(value);
  // @@protoc_insertion_point(field_set:CMsgTEGlowSprite.life)
}

// optional uint32 brightness = 4;
inline bool CMsgTEGlowSprite::_internal_has_brightness() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgTEGlowSprite::has_brightness() const {
  return _internal_has_brightness();
}
inline void CMsgTEGlowSprite::clear_brightness() {
  _impl_.brightness_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgTEGlowSprite::_internal_brightness() const {
  return _impl_.brightness_;
}
inline uint32_t CMsgTEGlowSprite::brightness() const {
  // @@protoc_insertion_point(field_get:CMsgTEGlowSprite.brightness)
  return _internal_brightness();
}
inline void CMsgTEGlowSprite::_internal_set_brightness(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.brightness_ = value;
}
inline void CMsgTEGlowSprite::set_brightness(uint32_t value) {
  _internal_set_brightness(value);
  // @@protoc_insertion_point(field_set:CMsgTEGlowSprite.brightness)
}

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

// CMsgTEImpact

// optional .CMsgVector origin = 1;
inline bool CMsgTEImpact::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CMsgTEImpact::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CMsgTEImpact::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEImpact::origin() const {
  // @@protoc_insertion_point(field_get:CMsgTEImpact.origin)
  return _internal_origin();
}
inline void CMsgTEImpact::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEImpact.origin)
}
inline ::CMsgVector* CMsgTEImpact::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTEImpact::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CMsgTEImpact.origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEImpact::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CMsgTEImpact::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CMsgTEImpact.origin)
  return _msg;
}
inline void CMsgTEImpact::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEImpact.origin)
}

// optional .CMsgVector normal = 2;
inline bool CMsgTEImpact::_internal_has_normal() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.normal_ != nullptr);
  return value;
}
inline bool CMsgTEImpact::has_normal() const {
  return _internal_has_normal();
}
inline const ::CMsgVector& CMsgTEImpact::_internal_normal() const {
  const ::CMsgVector* p = _impl_.normal_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEImpact::normal() const {
  // @@protoc_insertion_point(field_get:CMsgTEImpact.normal)
  return _internal_normal();
}
inline void CMsgTEImpact::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:CMsgTEImpact.normal)
}
inline ::CMsgVector* CMsgTEImpact::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* CMsgTEImpact::unsafe_arena_release_normal() {
  // @@protoc_insertion_point(field_release:CMsgTEImpact.normal)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.normal_;
  _impl_.normal_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEImpact::_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* CMsgTEImpact::mutable_normal() {
  ::CMsgVector* _msg = _internal_mutable_normal();
  // @@protoc_insertion_point(field_mutable:CMsgTEImpact.normal)
  return _msg;
}
inline void CMsgTEImpact::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:CMsgTEImpact.normal)
}

// optional uint32 type = 3;
inline bool CMsgTEImpact::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgTEImpact::has_type() const {
  return _internal_has_type();
}
inline void CMsgTEImpact::clear_type() {
  _impl_.type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgTEImpact::_internal_type() const {
  return _impl_.type_;
}
inline uint32_t CMsgTEImpact::type() const {
  // @@protoc_insertion_point(field_get:CMsgTEImpact.type)
  return _internal_type();
}
inline void CMsgTEImpact::_internal_set_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.type_ = value;
}
inline void CMsgTEImpact::set_type(uint32_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:CMsgTEImpact.type)
}

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

// CMsgTEMuzzleFlash

// optional .CMsgVector origin = 1;
inline bool CMsgTEMuzzleFlash::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CMsgTEMuzzleFlash::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CMsgTEMuzzleFlash::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEMuzzleFlash::origin() const {
  // @@protoc_insertion_point(field_get:CMsgTEMuzzleFlash.origin)
  return _internal_origin();
}
inline void CMsgTEMuzzleFlash::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEMuzzleFlash.origin)
}
inline ::CMsgVector* CMsgTEMuzzleFlash::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTEMuzzleFlash::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CMsgTEMuzzleFlash.origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEMuzzleFlash::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CMsgTEMuzzleFlash::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CMsgTEMuzzleFlash.origin)
  return _msg;
}
inline void CMsgTEMuzzleFlash::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEMuzzleFlash.origin)
}

// optional .CMsgQAngle angles = 2;
inline bool CMsgTEMuzzleFlash::_internal_has_angles() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.angles_ != nullptr);
  return value;
}
inline bool CMsgTEMuzzleFlash::has_angles() const {
  return _internal_has_angles();
}
inline const ::CMsgQAngle& CMsgTEMuzzleFlash::_internal_angles() const {
  const ::CMsgQAngle* p = _impl_.angles_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQAngle&>(
      ::_CMsgQAngle_default_instance_);
}
inline const ::CMsgQAngle& CMsgTEMuzzleFlash::angles() const {
  // @@protoc_insertion_point(field_get:CMsgTEMuzzleFlash.angles)
  return _internal_angles();
}
inline void CMsgTEMuzzleFlash::unsafe_arena_set_allocated_angles(
    ::CMsgQAngle* angles) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angles_);
  }
  _impl_.angles_ = angles;
  if (angles) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEMuzzleFlash.angles)
}
inline ::CMsgQAngle* CMsgTEMuzzleFlash::release_angles() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgQAngle* temp = _impl_.angles_;
  _impl_.angles_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgQAngle* CMsgTEMuzzleFlash::unsafe_arena_release_angles() {
  // @@protoc_insertion_point(field_release:CMsgTEMuzzleFlash.angles)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgQAngle* temp = _impl_.angles_;
  _impl_.angles_ = nullptr;
  return temp;
}
inline ::CMsgQAngle* CMsgTEMuzzleFlash::_internal_mutable_angles() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.angles_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgQAngle>(GetArenaForAllocation());
    _impl_.angles_ = p;
  }
  return _impl_.angles_;
}
inline ::CMsgQAngle* CMsgTEMuzzleFlash::mutable_angles() {
  ::CMsgQAngle* _msg = _internal_mutable_angles();
  // @@protoc_insertion_point(field_mutable:CMsgTEMuzzleFlash.angles)
  return _msg;
}
inline void CMsgTEMuzzleFlash::set_allocated_angles(::CMsgQAngle* angles) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angles_);
  }
  if (angles) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(angles));
    if (message_arena != submessage_arena) {
      angles = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, angles, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.angles_ = angles;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEMuzzleFlash.angles)
}

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

// optional uint32 type = 4;
inline bool CMsgTEMuzzleFlash::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgTEMuzzleFlash::has_type() const {
  return _internal_has_type();
}
inline void CMsgTEMuzzleFlash::clear_type() {
  _impl_.type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgTEMuzzleFlash::_internal_type() const {
  return _impl_.type_;
}
inline uint32_t CMsgTEMuzzleFlash::type() const {
  // @@protoc_insertion_point(field_get:CMsgTEMuzzleFlash.type)
  return _internal_type();
}
inline void CMsgTEMuzzleFlash::_internal_set_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.type_ = value;
}
inline void CMsgTEMuzzleFlash::set_type(uint32_t value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:CMsgTEMuzzleFlash.type)
}

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

// CMsgTEBloodStream

// optional .CMsgVector origin = 1;
inline bool CMsgTEBloodStream::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CMsgTEBloodStream::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CMsgTEBloodStream::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEBloodStream::origin() const {
  // @@protoc_insertion_point(field_get:CMsgTEBloodStream.origin)
  return _internal_origin();
}
inline void CMsgTEBloodStream::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEBloodStream.origin)
}
inline ::CMsgVector* CMsgTEBloodStream::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTEBloodStream::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CMsgTEBloodStream.origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEBloodStream::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CMsgTEBloodStream::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CMsgTEBloodStream.origin)
  return _msg;
}
inline void CMsgTEBloodStream::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEBloodStream.origin)
}

// optional .CMsgVector direction = 2;
inline bool CMsgTEBloodStream::_internal_has_direction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.direction_ != nullptr);
  return value;
}
inline bool CMsgTEBloodStream::has_direction() const {
  return _internal_has_direction();
}
inline const ::CMsgVector& CMsgTEBloodStream::_internal_direction() const {
  const ::CMsgVector* p = _impl_.direction_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEBloodStream::direction() const {
  // @@protoc_insertion_point(field_get:CMsgTEBloodStream.direction)
  return _internal_direction();
}
inline void CMsgTEBloodStream::unsafe_arena_set_allocated_direction(
    ::CMsgVector* direction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.direction_);
  }
  _impl_.direction_ = direction;
  if (direction) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEBloodStream.direction)
}
inline ::CMsgVector* CMsgTEBloodStream::release_direction() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.direction_;
  _impl_.direction_ = 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* CMsgTEBloodStream::unsafe_arena_release_direction() {
  // @@protoc_insertion_point(field_release:CMsgTEBloodStream.direction)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.direction_;
  _impl_.direction_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEBloodStream::_internal_mutable_direction() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.direction_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.direction_ = p;
  }
  return _impl_.direction_;
}
inline ::CMsgVector* CMsgTEBloodStream::mutable_direction() {
  ::CMsgVector* _msg = _internal_mutable_direction();
  // @@protoc_insertion_point(field_mutable:CMsgTEBloodStream.direction)
  return _msg;
}
inline void CMsgTEBloodStream::set_allocated_direction(::CMsgVector* direction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.direction_);
  }
  if (direction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(direction));
    if (message_arena != submessage_arena) {
      direction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, direction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.direction_ = direction;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEBloodStream.direction)
}

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

// optional uint32 amount = 4;
inline bool CMsgTEBloodStream::_internal_has_amount() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgTEBloodStream::has_amount() const {
  return _internal_has_amount();
}
inline void CMsgTEBloodStream::clear_amount() {
  _impl_.amount_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgTEBloodStream::_internal_amount() const {
  return _impl_.amount_;
}
inline uint32_t CMsgTEBloodStream::amount() const {
  // @@protoc_insertion_point(field_get:CMsgTEBloodStream.amount)
  return _internal_amount();
}
inline void CMsgTEBloodStream::_internal_set_amount(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.amount_ = value;
}
inline void CMsgTEBloodStream::set_amount(uint32_t value) {
  _internal_set_amount(value);
  // @@protoc_insertion_point(field_set:CMsgTEBloodStream.amount)
}

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

// CMsgTEExplosion

// optional .CMsgVector origin = 1;
inline bool CMsgTEExplosion::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CMsgTEExplosion::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CMsgTEExplosion::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEExplosion::origin() const {
  // @@protoc_insertion_point(field_get:CMsgTEExplosion.origin)
  return _internal_origin();
}
inline void CMsgTEExplosion::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEExplosion.origin)
}
inline ::CMsgVector* CMsgTEExplosion::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTEExplosion::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CMsgTEExplosion.origin)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEExplosion::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CMsgTEExplosion::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CMsgTEExplosion.origin)
  return _msg;
}
inline void CMsgTEExplosion::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEExplosion.origin)
}

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

// optional .CMsgVector normal = 4;
inline bool CMsgTEExplosion::_internal_has_normal() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.normal_ != nullptr);
  return value;
}
inline bool CMsgTEExplosion::has_normal() const {
  return _internal_has_normal();
}
inline const ::CMsgVector& CMsgTEExplosion::_internal_normal() const {
  const ::CMsgVector* p = _impl_.normal_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEExplosion::normal() const {
  // @@protoc_insertion_point(field_get:CMsgTEExplosion.normal)
  return _internal_normal();
}
inline void CMsgTEExplosion::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] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEExplosion.normal)
}
inline ::CMsgVector* CMsgTEExplosion::release_normal() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::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* CMsgTEExplosion::unsafe_arena_release_normal() {
  // @@protoc_insertion_point(field_release:CMsgTEExplosion.normal)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgVector* temp = _impl_.normal_;
  _impl_.normal_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEExplosion::_internal_mutable_normal() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.normal_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.normal_ = p;
  }
  return _impl_.normal_;
}
inline ::CMsgVector* CMsgTEExplosion::mutable_normal() {
  ::CMsgVector* _msg = _internal_mutable_normal();
  // @@protoc_insertion_point(field_mutable:CMsgTEExplosion.normal)
  return _msg;
}
inline void CMsgTEExplosion::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] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.normal_ = normal;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEExplosion.normal)
}

// optional uint32 radius = 6;
inline bool CMsgTEExplosion::_internal_has_radius() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgTEExplosion::has_radius() const {
  return _internal_has_radius();
}
inline void CMsgTEExplosion::clear_radius() {
  _impl_.radius_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgTEExplosion::_internal_radius() const {
  return _impl_.radius_;
}
inline uint32_t CMsgTEExplosion::radius() const {
  // @@protoc_insertion_point(field_get:CMsgTEExplosion.radius)
  return _internal_radius();
}
inline void CMsgTEExplosion::_internal_set_radius(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.radius_ = value;
}
inline void CMsgTEExplosion::set_radius(uint32_t value) {
  _internal_set_radius(value);
  // @@protoc_insertion_point(field_set:CMsgTEExplosion.radius)
}

// optional uint32 magnitude = 7;
inline bool CMsgTEExplosion::_internal_has_magnitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgTEExplosion::has_magnitude() const {
  return _internal_has_magnitude();
}
inline void CMsgTEExplosion::clear_magnitude() {
  _impl_.magnitude_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgTEExplosion::_internal_magnitude() const {
  return _impl_.magnitude_;
}
inline uint32_t CMsgTEExplosion::magnitude() const {
  // @@protoc_insertion_point(field_get:CMsgTEExplosion.magnitude)
  return _internal_magnitude();
}
inline void CMsgTEExplosion::_internal_set_magnitude(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.magnitude_ = value;
}
inline void CMsgTEExplosion::set_magnitude(uint32_t value) {
  _internal_set_magnitude(value);
  // @@protoc_insertion_point(field_set:CMsgTEExplosion.magnitude)
}

// optional bool affect_ragdolls = 9;
inline bool CMsgTEExplosion::_internal_has_affect_ragdolls() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgTEExplosion::has_affect_ragdolls() const {
  return _internal_has_affect_ragdolls();
}
inline void CMsgTEExplosion::clear_affect_ragdolls() {
  _impl_.affect_ragdolls_ = false;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline bool CMsgTEExplosion::_internal_affect_ragdolls() const {
  return _impl_.affect_ragdolls_;
}
inline bool CMsgTEExplosion::affect_ragdolls() const {
  // @@protoc_insertion_point(field_get:CMsgTEExplosion.affect_ragdolls)
  return _internal_affect_ragdolls();
}
inline void CMsgTEExplosion::_internal_set_affect_ragdolls(bool value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.affect_ragdolls_ = value;
}
inline void CMsgTEExplosion::set_affect_ragdolls(bool value) {
  _internal_set_affect_ragdolls(value);
  // @@protoc_insertion_point(field_set:CMsgTEExplosion.affect_ragdolls)
}

// optional string sound_name = 10;
inline bool CMsgTEExplosion::_internal_has_sound_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgTEExplosion::has_sound_name() const {
  return _internal_has_sound_name();
}
inline void CMsgTEExplosion::clear_sound_name() {
  _impl_.sound_name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgTEExplosion::sound_name() const {
  // @@protoc_insertion_point(field_get:CMsgTEExplosion.sound_name)
  return _internal_sound_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgTEExplosion::set_sound_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.sound_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgTEExplosion.sound_name)
}
inline std::string* CMsgTEExplosion::mutable_sound_name() {
  std::string* _s = _internal_mutable_sound_name();
  // @@protoc_insertion_point(field_mutable:CMsgTEExplosion.sound_name)
  return _s;
}
inline const std::string& CMsgTEExplosion::_internal_sound_name() const {
  return _impl_.sound_name_.Get();
}
inline void CMsgTEExplosion::_internal_set_sound_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.sound_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgTEExplosion::_internal_mutable_sound_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.sound_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgTEExplosion::release_sound_name() {
  // @@protoc_insertion_point(field_release:CMsgTEExplosion.sound_name)
  if (!_internal_has_sound_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.sound_name_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sound_name_.IsDefault()) {
    _impl_.sound_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgTEExplosion::set_allocated_sound_name(std::string* sound_name) {
  if (sound_name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.sound_name_.SetAllocated(sound_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sound_name_.IsDefault()) {
    _impl_.sound_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgTEExplosion.sound_name)
}

// optional uint32 explosion_type = 11;
inline bool CMsgTEExplosion::_internal_has_explosion_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgTEExplosion::has_explosion_type() const {
  return _internal_has_explosion_type();
}
inline void CMsgTEExplosion::clear_explosion_type() {
  _impl_.explosion_type_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t CMsgTEExplosion::_internal_explosion_type() const {
  return _impl_.explosion_type_;
}
inline uint32_t CMsgTEExplosion::explosion_type() const {
  // @@protoc_insertion_point(field_get:CMsgTEExplosion.explosion_type)
  return _internal_explosion_type();
}
inline void CMsgTEExplosion::_internal_set_explosion_type(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.explosion_type_ = value;
}
inline void CMsgTEExplosion::set_explosion_type(uint32_t value) {
  _internal_set_explosion_type(value);
  // @@protoc_insertion_point(field_set:CMsgTEExplosion.explosion_type)
}

// optional bool create_debris = 12;
inline bool CMsgTEExplosion::_internal_has_create_debris() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgTEExplosion::has_create_debris() const {
  return _internal_has_create_debris();
}
inline void CMsgTEExplosion::clear_create_debris() {
  _impl_.create_debris_ = false;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline bool CMsgTEExplosion::_internal_create_debris() const {
  return _impl_.create_debris_;
}
inline bool CMsgTEExplosion::create_debris() const {
  // @@protoc_insertion_point(field_get:CMsgTEExplosion.create_debris)
  return _internal_create_debris();
}
inline void CMsgTEExplosion::_internal_set_create_debris(bool value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.create_debris_ = value;
}
inline void CMsgTEExplosion::set_create_debris(bool value) {
  _internal_set_create_debris(value);
  // @@protoc_insertion_point(field_set:CMsgTEExplosion.create_debris)
}

// optional .CMsgVector debris_origin = 13;
inline bool CMsgTEExplosion::_internal_has_debris_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.debris_origin_ != nullptr);
  return value;
}
inline bool CMsgTEExplosion::has_debris_origin() const {
  return _internal_has_debris_origin();
}
inline const ::CMsgVector& CMsgTEExplosion::_internal_debris_origin() const {
  const ::CMsgVector* p = _impl_.debris_origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEExplosion::debris_origin() const {
  // @@protoc_insertion_point(field_get:CMsgTEExplosion.debris_origin)
  return _internal_debris_origin();
}
inline void CMsgTEExplosion::unsafe_arena_set_allocated_debris_origin(
    ::CMsgVector* debris_origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.debris_origin_);
  }
  _impl_.debris_origin_ = debris_origin;
  if (debris_origin) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEExplosion.debris_origin)
}
inline ::CMsgVector* CMsgTEExplosion::release_debris_origin() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgVector* temp = _impl_.debris_origin_;
  _impl_.debris_origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTEExplosion::unsafe_arena_release_debris_origin() {
  // @@protoc_insertion_point(field_release:CMsgTEExplosion.debris_origin)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgVector* temp = _impl_.debris_origin_;
  _impl_.debris_origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEExplosion::_internal_mutable_debris_origin() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.debris_origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.debris_origin_ = p;
  }
  return _impl_.debris_origin_;
}
inline ::CMsgVector* CMsgTEExplosion::mutable_debris_origin() {
  ::CMsgVector* _msg = _internal_mutable_debris_origin();
  // @@protoc_insertion_point(field_mutable:CMsgTEExplosion.debris_origin)
  return _msg;
}
inline void CMsgTEExplosion::set_allocated_debris_origin(::CMsgVector* debris_origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.debris_origin_);
  }
  if (debris_origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(debris_origin));
    if (message_arena != submessage_arena) {
      debris_origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, debris_origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.debris_origin_ = debris_origin;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEExplosion.debris_origin)
}

// optional fixed32 debris_surfaceprop = 14;
inline bool CMsgTEExplosion::_internal_has_debris_surfaceprop() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgTEExplosion::has_debris_surfaceprop() const {
  return _internal_has_debris_surfaceprop();
}
inline void CMsgTEExplosion::clear_debris_surfaceprop() {
  _impl_.debris_surfaceprop_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CMsgTEExplosion::_internal_debris_surfaceprop() const {
  return _impl_.debris_surfaceprop_;
}
inline uint32_t CMsgTEExplosion::debris_surfaceprop() const {
  // @@protoc_insertion_point(field_get:CMsgTEExplosion.debris_surfaceprop)
  return _internal_debris_surfaceprop();
}
inline void CMsgTEExplosion::_internal_set_debris_surfaceprop(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.debris_surfaceprop_ = value;
}
inline void CMsgTEExplosion::set_debris_surfaceprop(uint32_t value) {
  _internal_set_debris_surfaceprop(value);
  // @@protoc_insertion_point(field_set:CMsgTEExplosion.debris_surfaceprop)
}

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

// CMsgTEDust

// optional .CMsgVector origin = 1;
inline bool CMsgTEDust::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CMsgTEDust::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CMsgTEDust::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEDust::origin() const {
  // @@protoc_insertion_point(field_get:CMsgTEDust.origin)
  return _internal_origin();
}
inline void CMsgTEDust::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEDust.origin)
}
inline ::CMsgVector* CMsgTEDust::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTEDust::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CMsgTEDust.origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEDust::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CMsgTEDust::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CMsgTEDust.origin)
  return _msg;
}
inline void CMsgTEDust::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEDust.origin)
}

// optional float size = 2;
inline bool CMsgTEDust::_internal_has_size() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgTEDust::has_size() const {
  return _internal_has_size();
}
inline void CMsgTEDust::clear_size() {
  _impl_.size_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CMsgTEDust::_internal_size() const {
  return _impl_.size_;
}
inline float CMsgTEDust::size() const {
  // @@protoc_insertion_point(field_get:CMsgTEDust.size)
  return _internal_size();
}
inline void CMsgTEDust::_internal_set_size(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.size_ = value;
}
inline void CMsgTEDust::set_size(float value) {
  _internal_set_size(value);
  // @@protoc_insertion_point(field_set:CMsgTEDust.size)
}

// optional float speed = 3;
inline bool CMsgTEDust::_internal_has_speed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgTEDust::has_speed() const {
  return _internal_has_speed();
}
inline void CMsgTEDust::clear_speed() {
  _impl_.speed_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float CMsgTEDust::_internal_speed() const {
  return _impl_.speed_;
}
inline float CMsgTEDust::speed() const {
  // @@protoc_insertion_point(field_get:CMsgTEDust.speed)
  return _internal_speed();
}
inline void CMsgTEDust::_internal_set_speed(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.speed_ = value;
}
inline void CMsgTEDust::set_speed(float value) {
  _internal_set_speed(value);
  // @@protoc_insertion_point(field_set:CMsgTEDust.speed)
}

// optional .CMsgVector direction = 4;
inline bool CMsgTEDust::_internal_has_direction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.direction_ != nullptr);
  return value;
}
inline bool CMsgTEDust::has_direction() const {
  return _internal_has_direction();
}
inline const ::CMsgVector& CMsgTEDust::_internal_direction() const {
  const ::CMsgVector* p = _impl_.direction_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEDust::direction() const {
  // @@protoc_insertion_point(field_get:CMsgTEDust.direction)
  return _internal_direction();
}
inline void CMsgTEDust::unsafe_arena_set_allocated_direction(
    ::CMsgVector* direction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.direction_);
  }
  _impl_.direction_ = direction;
  if (direction) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEDust.direction)
}
inline ::CMsgVector* CMsgTEDust::release_direction() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.direction_;
  _impl_.direction_ = 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* CMsgTEDust::unsafe_arena_release_direction() {
  // @@protoc_insertion_point(field_release:CMsgTEDust.direction)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.direction_;
  _impl_.direction_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEDust::_internal_mutable_direction() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.direction_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.direction_ = p;
  }
  return _impl_.direction_;
}
inline ::CMsgVector* CMsgTEDust::mutable_direction() {
  ::CMsgVector* _msg = _internal_mutable_direction();
  // @@protoc_insertion_point(field_mutable:CMsgTEDust.direction)
  return _msg;
}
inline void CMsgTEDust::set_allocated_direction(::CMsgVector* direction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.direction_);
  }
  if (direction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(direction));
    if (message_arena != submessage_arena) {
      direction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, direction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.direction_ = direction;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEDust.direction)
}

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

// CMsgTELargeFunnel

// optional .CMsgVector origin = 1;
inline bool CMsgTELargeFunnel::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CMsgTELargeFunnel::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CMsgTELargeFunnel::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTELargeFunnel::origin() const {
  // @@protoc_insertion_point(field_get:CMsgTELargeFunnel.origin)
  return _internal_origin();
}
inline void CMsgTELargeFunnel::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTELargeFunnel.origin)
}
inline ::CMsgVector* CMsgTELargeFunnel::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTELargeFunnel::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CMsgTELargeFunnel.origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTELargeFunnel::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CMsgTELargeFunnel::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CMsgTELargeFunnel.origin)
  return _msg;
}
inline void CMsgTELargeFunnel::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CMsgTELargeFunnel.origin)
}

// optional uint32 reversed = 2;
inline bool CMsgTELargeFunnel::_internal_has_reversed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgTELargeFunnel::has_reversed() const {
  return _internal_has_reversed();
}
inline void CMsgTELargeFunnel::clear_reversed() {
  _impl_.reversed_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgTELargeFunnel::_internal_reversed() const {
  return _impl_.reversed_;
}
inline uint32_t CMsgTELargeFunnel::reversed() const {
  // @@protoc_insertion_point(field_get:CMsgTELargeFunnel.reversed)
  return _internal_reversed();
}
inline void CMsgTELargeFunnel::_internal_set_reversed(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.reversed_ = value;
}
inline void CMsgTELargeFunnel::set_reversed(uint32_t value) {
  _internal_set_reversed(value);
  // @@protoc_insertion_point(field_set:CMsgTELargeFunnel.reversed)
}

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

// CMsgTESparks

// optional .CMsgVector origin = 1;
inline bool CMsgTESparks::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CMsgTESparks::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CMsgTESparks::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTESparks::origin() const {
  // @@protoc_insertion_point(field_get:CMsgTESparks.origin)
  return _internal_origin();
}
inline void CMsgTESparks::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTESparks.origin)
}
inline ::CMsgVector* CMsgTESparks::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTESparks::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CMsgTESparks.origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTESparks::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CMsgTESparks::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CMsgTESparks.origin)
  return _msg;
}
inline void CMsgTESparks::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CMsgTESparks.origin)
}

// optional uint32 magnitude = 2;
inline bool CMsgTESparks::_internal_has_magnitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgTESparks::has_magnitude() const {
  return _internal_has_magnitude();
}
inline void CMsgTESparks::clear_magnitude() {
  _impl_.magnitude_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgTESparks::_internal_magnitude() const {
  return _impl_.magnitude_;
}
inline uint32_t CMsgTESparks::magnitude() const {
  // @@protoc_insertion_point(field_get:CMsgTESparks.magnitude)
  return _internal_magnitude();
}
inline void CMsgTESparks::_internal_set_magnitude(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.magnitude_ = value;
}
inline void CMsgTESparks::set_magnitude(uint32_t value) {
  _internal_set_magnitude(value);
  // @@protoc_insertion_point(field_set:CMsgTESparks.magnitude)
}

// optional uint32 length = 3;
inline bool CMsgTESparks::_internal_has_length() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgTESparks::has_length() const {
  return _internal_has_length();
}
inline void CMsgTESparks::clear_length() {
  _impl_.length_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgTESparks::_internal_length() const {
  return _impl_.length_;
}
inline uint32_t CMsgTESparks::length() const {
  // @@protoc_insertion_point(field_get:CMsgTESparks.length)
  return _internal_length();
}
inline void CMsgTESparks::_internal_set_length(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.length_ = value;
}
inline void CMsgTESparks::set_length(uint32_t value) {
  _internal_set_length(value);
  // @@protoc_insertion_point(field_set:CMsgTESparks.length)
}

// optional .CMsgVector direction = 4;
inline bool CMsgTESparks::_internal_has_direction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.direction_ != nullptr);
  return value;
}
inline bool CMsgTESparks::has_direction() const {
  return _internal_has_direction();
}
inline const ::CMsgVector& CMsgTESparks::_internal_direction() const {
  const ::CMsgVector* p = _impl_.direction_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTESparks::direction() const {
  // @@protoc_insertion_point(field_get:CMsgTESparks.direction)
  return _internal_direction();
}
inline void CMsgTESparks::unsafe_arena_set_allocated_direction(
    ::CMsgVector* direction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.direction_);
  }
  _impl_.direction_ = direction;
  if (direction) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTESparks.direction)
}
inline ::CMsgVector* CMsgTESparks::release_direction() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.direction_;
  _impl_.direction_ = 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* CMsgTESparks::unsafe_arena_release_direction() {
  // @@protoc_insertion_point(field_release:CMsgTESparks.direction)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.direction_;
  _impl_.direction_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTESparks::_internal_mutable_direction() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.direction_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.direction_ = p;
  }
  return _impl_.direction_;
}
inline ::CMsgVector* CMsgTESparks::mutable_direction() {
  ::CMsgVector* _msg = _internal_mutable_direction();
  // @@protoc_insertion_point(field_mutable:CMsgTESparks.direction)
  return _msg;
}
inline void CMsgTESparks::set_allocated_direction(::CMsgVector* direction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.direction_);
  }
  if (direction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(direction));
    if (message_arena != submessage_arena) {
      direction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, direction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.direction_ = direction;
  // @@protoc_insertion_point(field_set_allocated:CMsgTESparks.direction)
}

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

// CMsgTEPhysicsProp

// optional .CMsgVector origin = 1;
inline bool CMsgTEPhysicsProp::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CMsgTEPhysicsProp::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CMsgTEPhysicsProp::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEPhysicsProp::origin() const {
  // @@protoc_insertion_point(field_get:CMsgTEPhysicsProp.origin)
  return _internal_origin();
}
inline void CMsgTEPhysicsProp::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEPhysicsProp.origin)
}
inline ::CMsgVector* CMsgTEPhysicsProp::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTEPhysicsProp::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CMsgTEPhysicsProp.origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEPhysicsProp::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CMsgTEPhysicsProp::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CMsgTEPhysicsProp.origin)
  return _msg;
}
inline void CMsgTEPhysicsProp::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEPhysicsProp.origin)
}

// optional .CMsgVector velocity = 2;
inline bool CMsgTEPhysicsProp::_internal_has_velocity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.velocity_ != nullptr);
  return value;
}
inline bool CMsgTEPhysicsProp::has_velocity() const {
  return _internal_has_velocity();
}
inline const ::CMsgVector& CMsgTEPhysicsProp::_internal_velocity() const {
  const ::CMsgVector* p = _impl_.velocity_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEPhysicsProp::velocity() const {
  // @@protoc_insertion_point(field_get:CMsgTEPhysicsProp.velocity)
  return _internal_velocity();
}
inline void CMsgTEPhysicsProp::unsafe_arena_set_allocated_velocity(
    ::CMsgVector* velocity) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.velocity_);
  }
  _impl_.velocity_ = velocity;
  if (velocity) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEPhysicsProp.velocity)
}
inline ::CMsgVector* CMsgTEPhysicsProp::release_velocity() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.velocity_;
  _impl_.velocity_ = 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* CMsgTEPhysicsProp::unsafe_arena_release_velocity() {
  // @@protoc_insertion_point(field_release:CMsgTEPhysicsProp.velocity)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.velocity_;
  _impl_.velocity_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEPhysicsProp::_internal_mutable_velocity() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.velocity_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.velocity_ = p;
  }
  return _impl_.velocity_;
}
inline ::CMsgVector* CMsgTEPhysicsProp::mutable_velocity() {
  ::CMsgVector* _msg = _internal_mutable_velocity();
  // @@protoc_insertion_point(field_mutable:CMsgTEPhysicsProp.velocity)
  return _msg;
}
inline void CMsgTEPhysicsProp::set_allocated_velocity(::CMsgVector* velocity) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.velocity_);
  }
  if (velocity) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(velocity));
    if (message_arena != submessage_arena) {
      velocity = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, velocity, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.velocity_ = velocity;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEPhysicsProp.velocity)
}

// optional .CMsgQAngle angles = 3;
inline bool CMsgTEPhysicsProp::_internal_has_angles() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.angles_ != nullptr);
  return value;
}
inline bool CMsgTEPhysicsProp::has_angles() const {
  return _internal_has_angles();
}
inline const ::CMsgQAngle& CMsgTEPhysicsProp::_internal_angles() const {
  const ::CMsgQAngle* p = _impl_.angles_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQAngle&>(
      ::_CMsgQAngle_default_instance_);
}
inline const ::CMsgQAngle& CMsgTEPhysicsProp::angles() const {
  // @@protoc_insertion_point(field_get:CMsgTEPhysicsProp.angles)
  return _internal_angles();
}
inline void CMsgTEPhysicsProp::unsafe_arena_set_allocated_angles(
    ::CMsgQAngle* angles) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angles_);
  }
  _impl_.angles_ = angles;
  if (angles) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEPhysicsProp.angles)
}
inline ::CMsgQAngle* CMsgTEPhysicsProp::release_angles() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgQAngle* temp = _impl_.angles_;
  _impl_.angles_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgQAngle* CMsgTEPhysicsProp::unsafe_arena_release_angles() {
  // @@protoc_insertion_point(field_release:CMsgTEPhysicsProp.angles)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgQAngle* temp = _impl_.angles_;
  _impl_.angles_ = nullptr;
  return temp;
}
inline ::CMsgQAngle* CMsgTEPhysicsProp::_internal_mutable_angles() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.angles_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgQAngle>(GetArenaForAllocation());
    _impl_.angles_ = p;
  }
  return _impl_.angles_;
}
inline ::CMsgQAngle* CMsgTEPhysicsProp::mutable_angles() {
  ::CMsgQAngle* _msg = _internal_mutable_angles();
  // @@protoc_insertion_point(field_mutable:CMsgTEPhysicsProp.angles)
  return _msg;
}
inline void CMsgTEPhysicsProp::set_allocated_angles(::CMsgQAngle* angles) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.angles_);
  }
  if (angles) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(angles));
    if (message_arena != submessage_arena) {
      angles = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, angles, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.angles_ = angles;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEPhysicsProp.angles)
}

// optional fixed32 skin = 4;
inline bool CMsgTEPhysicsProp::_internal_has_skin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgTEPhysicsProp::has_skin() const {
  return _internal_has_skin();
}
inline void CMsgTEPhysicsProp::clear_skin() {
  _impl_.skin_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgTEPhysicsProp::_internal_skin() const {
  return _impl_.skin_;
}
inline uint32_t CMsgTEPhysicsProp::skin() const {
  // @@protoc_insertion_point(field_get:CMsgTEPhysicsProp.skin)
  return _internal_skin();
}
inline void CMsgTEPhysicsProp::_internal_set_skin(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.skin_ = value;
}
inline void CMsgTEPhysicsProp::set_skin(uint32_t value) {
  _internal_set_skin(value);
  // @@protoc_insertion_point(field_set:CMsgTEPhysicsProp.skin)
}

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

// optional uint32 effects = 6;
inline bool CMsgTEPhysicsProp::_internal_has_effects() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgTEPhysicsProp::has_effects() const {
  return _internal_has_effects();
}
inline void CMsgTEPhysicsProp::clear_effects() {
  _impl_.effects_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgTEPhysicsProp::_internal_effects() const {
  return _impl_.effects_;
}
inline uint32_t CMsgTEPhysicsProp::effects() const {
  // @@protoc_insertion_point(field_get:CMsgTEPhysicsProp.effects)
  return _internal_effects();
}
inline void CMsgTEPhysicsProp::_internal_set_effects(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.effects_ = value;
}
inline void CMsgTEPhysicsProp::set_effects(uint32_t value) {
  _internal_set_effects(value);
  // @@protoc_insertion_point(field_set:CMsgTEPhysicsProp.effects)
}

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

// optional fixed64 modelindex = 8;
inline bool CMsgTEPhysicsProp::_internal_has_modelindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgTEPhysicsProp::has_modelindex() const {
  return _internal_has_modelindex();
}
inline void CMsgTEPhysicsProp::clear_modelindex() {
  _impl_.modelindex_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint64_t CMsgTEPhysicsProp::_internal_modelindex() const {
  return _impl_.modelindex_;
}
inline uint64_t CMsgTEPhysicsProp::modelindex() const {
  // @@protoc_insertion_point(field_get:CMsgTEPhysicsProp.modelindex)
  return _internal_modelindex();
}
inline void CMsgTEPhysicsProp::_internal_set_modelindex(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.modelindex_ = value;
}
inline void CMsgTEPhysicsProp::set_modelindex(uint64_t value) {
  _internal_set_modelindex(value);
  // @@protoc_insertion_point(field_set:CMsgTEPhysicsProp.modelindex)
}

// optional uint32 unused_breakmodelsnottomake = 9;
inline bool CMsgTEPhysicsProp::_internal_has_unused_breakmodelsnottomake() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgTEPhysicsProp::has_unused_breakmodelsnottomake() const {
  return _internal_has_unused_breakmodelsnottomake();
}
inline void CMsgTEPhysicsProp::clear_unused_breakmodelsnottomake() {
  _impl_.unused_breakmodelsnottomake_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CMsgTEPhysicsProp::_internal_unused_breakmodelsnottomake() const {
  return _impl_.unused_breakmodelsnottomake_;
}
inline uint32_t CMsgTEPhysicsProp::unused_breakmodelsnottomake() const {
  // @@protoc_insertion_point(field_get:CMsgTEPhysicsProp.unused_breakmodelsnottomake)
  return _internal_unused_breakmodelsnottomake();
}
inline void CMsgTEPhysicsProp::_internal_set_unused_breakmodelsnottomake(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.unused_breakmodelsnottomake_ = value;
}
inline void CMsgTEPhysicsProp::set_unused_breakmodelsnottomake(uint32_t value) {
  _internal_set_unused_breakmodelsnottomake(value);
  // @@protoc_insertion_point(field_set:CMsgTEPhysicsProp.unused_breakmodelsnottomake)
}

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

// optional .CMsgVector dmgpos = 11;
inline bool CMsgTEPhysicsProp::_internal_has_dmgpos() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.dmgpos_ != nullptr);
  return value;
}
inline bool CMsgTEPhysicsProp::has_dmgpos() const {
  return _internal_has_dmgpos();
}
inline const ::CMsgVector& CMsgTEPhysicsProp::_internal_dmgpos() const {
  const ::CMsgVector* p = _impl_.dmgpos_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEPhysicsProp::dmgpos() const {
  // @@protoc_insertion_point(field_get:CMsgTEPhysicsProp.dmgpos)
  return _internal_dmgpos();
}
inline void CMsgTEPhysicsProp::unsafe_arena_set_allocated_dmgpos(
    ::CMsgVector* dmgpos) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dmgpos_);
  }
  _impl_.dmgpos_ = dmgpos;
  if (dmgpos) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEPhysicsProp.dmgpos)
}
inline ::CMsgVector* CMsgTEPhysicsProp::release_dmgpos() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgVector* temp = _impl_.dmgpos_;
  _impl_.dmgpos_ = 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* CMsgTEPhysicsProp::unsafe_arena_release_dmgpos() {
  // @@protoc_insertion_point(field_release:CMsgTEPhysicsProp.dmgpos)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgVector* temp = _impl_.dmgpos_;
  _impl_.dmgpos_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEPhysicsProp::_internal_mutable_dmgpos() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.dmgpos_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.dmgpos_ = p;
  }
  return _impl_.dmgpos_;
}
inline ::CMsgVector* CMsgTEPhysicsProp::mutable_dmgpos() {
  ::CMsgVector* _msg = _internal_mutable_dmgpos();
  // @@protoc_insertion_point(field_mutable:CMsgTEPhysicsProp.dmgpos)
  return _msg;
}
inline void CMsgTEPhysicsProp::set_allocated_dmgpos(::CMsgVector* dmgpos) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dmgpos_);
  }
  if (dmgpos) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dmgpos));
    if (message_arena != submessage_arena) {
      dmgpos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dmgpos, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.dmgpos_ = dmgpos;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEPhysicsProp.dmgpos)
}

// optional .CMsgVector dmgdir = 12;
inline bool CMsgTEPhysicsProp::_internal_has_dmgdir() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.dmgdir_ != nullptr);
  return value;
}
inline bool CMsgTEPhysicsProp::has_dmgdir() const {
  return _internal_has_dmgdir();
}
inline const ::CMsgVector& CMsgTEPhysicsProp::_internal_dmgdir() const {
  const ::CMsgVector* p = _impl_.dmgdir_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEPhysicsProp::dmgdir() const {
  // @@protoc_insertion_point(field_get:CMsgTEPhysicsProp.dmgdir)
  return _internal_dmgdir();
}
inline void CMsgTEPhysicsProp::unsafe_arena_set_allocated_dmgdir(
    ::CMsgVector* dmgdir) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dmgdir_);
  }
  _impl_.dmgdir_ = dmgdir;
  if (dmgdir) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEPhysicsProp.dmgdir)
}
inline ::CMsgVector* CMsgTEPhysicsProp::release_dmgdir() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgVector* temp = _impl_.dmgdir_;
  _impl_.dmgdir_ = 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* CMsgTEPhysicsProp::unsafe_arena_release_dmgdir() {
  // @@protoc_insertion_point(field_release:CMsgTEPhysicsProp.dmgdir)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgVector* temp = _impl_.dmgdir_;
  _impl_.dmgdir_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEPhysicsProp::_internal_mutable_dmgdir() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.dmgdir_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.dmgdir_ = p;
  }
  return _impl_.dmgdir_;
}
inline ::CMsgVector* CMsgTEPhysicsProp::mutable_dmgdir() {
  ::CMsgVector* _msg = _internal_mutable_dmgdir();
  // @@protoc_insertion_point(field_mutable:CMsgTEPhysicsProp.dmgdir)
  return _msg;
}
inline void CMsgTEPhysicsProp::set_allocated_dmgdir(::CMsgVector* dmgdir) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dmgdir_);
  }
  if (dmgdir) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dmgdir));
    if (message_arena != submessage_arena) {
      dmgdir = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dmgdir, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.dmgdir_ = dmgdir;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEPhysicsProp.dmgdir)
}

// optional int32 dmgtype = 13;
inline bool CMsgTEPhysicsProp::_internal_has_dmgtype() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CMsgTEPhysicsProp::has_dmgtype() const {
  return _internal_has_dmgtype();
}
inline void CMsgTEPhysicsProp::clear_dmgtype() {
  _impl_.dmgtype_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline int32_t CMsgTEPhysicsProp::_internal_dmgtype() const {
  return _impl_.dmgtype_;
}
inline int32_t CMsgTEPhysicsProp::dmgtype() const {
  // @@protoc_insertion_point(field_get:CMsgTEPhysicsProp.dmgtype)
  return _internal_dmgtype();
}
inline void CMsgTEPhysicsProp::_internal_set_dmgtype(int32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.dmgtype_ = value;
}
inline void CMsgTEPhysicsProp::set_dmgtype(int32_t value) {
  _internal_set_dmgtype(value);
  // @@protoc_insertion_point(field_set:CMsgTEPhysicsProp.dmgtype)
}

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

// CMsgTESmoke

// optional .CMsgVector origin = 1;
inline bool CMsgTESmoke::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CMsgTESmoke::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CMsgTESmoke::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTESmoke::origin() const {
  // @@protoc_insertion_point(field_get:CMsgTESmoke.origin)
  return _internal_origin();
}
inline void CMsgTESmoke::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTESmoke.origin)
}
inline ::CMsgVector* CMsgTESmoke::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTESmoke::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CMsgTESmoke.origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTESmoke::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CMsgTESmoke::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CMsgTESmoke.origin)
  return _msg;
}
inline void CMsgTESmoke::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CMsgTESmoke.origin)
}

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

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

// CMsgTEWorldDecal

// optional .CMsgVector origin = 1;
inline bool CMsgTEWorldDecal::_internal_has_origin() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.origin_ != nullptr);
  return value;
}
inline bool CMsgTEWorldDecal::has_origin() const {
  return _internal_has_origin();
}
inline const ::CMsgVector& CMsgTEWorldDecal::_internal_origin() const {
  const ::CMsgVector* p = _impl_.origin_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEWorldDecal::origin() const {
  // @@protoc_insertion_point(field_get:CMsgTEWorldDecal.origin)
  return _internal_origin();
}
inline void CMsgTEWorldDecal::unsafe_arena_set_allocated_origin(
    ::CMsgVector* origin) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  _impl_.origin_ = origin;
  if (origin) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgTEWorldDecal.origin)
}
inline ::CMsgVector* CMsgTEWorldDecal::release_origin() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgVector* CMsgTEWorldDecal::unsafe_arena_release_origin() {
  // @@protoc_insertion_point(field_release:CMsgTEWorldDecal.origin)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgVector* temp = _impl_.origin_;
  _impl_.origin_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEWorldDecal::_internal_mutable_origin() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.origin_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgVector>(GetArenaForAllocation());
    _impl_.origin_ = p;
  }
  return _impl_.origin_;
}
inline ::CMsgVector* CMsgTEWorldDecal::mutable_origin() {
  ::CMsgVector* _msg = _internal_mutable_origin();
  // @@protoc_insertion_point(field_mutable:CMsgTEWorldDecal.origin)
  return _msg;
}
inline void CMsgTEWorldDecal::set_allocated_origin(::CMsgVector* origin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.origin_);
  }
  if (origin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(origin));
    if (message_arena != submessage_arena) {
      origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, origin, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.origin_ = origin;
  // @@protoc_insertion_point(field_set_allocated:CMsgTEWorldDecal.origin)
}

// optional .CMsgVector normal = 2;
inline bool CMsgTEWorldDecal::_internal_has_normal() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.normal_ != nullptr);
  return value;
}
inline bool CMsgTEWorldDecal::has_normal() const {
  return _internal_has_normal();
}
inline const ::CMsgVector& CMsgTEWorldDecal::_internal_normal() const {
  const ::CMsgVector* p = _impl_.normal_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgVector&>(
      ::_CMsgVector_default_instance_);
}
inline const ::CMsgVector& CMsgTEWorldDecal::normal() const {
  // @@protoc_insertion_point(field_get:CMsgTEWorldDecal.normal)
  return _internal_normal();
}
inline void CMsgTEWorldDecal::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:CMsgTEWorldDecal.normal)
}
inline ::CMsgVector* CMsgTEWorldDecal::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* CMsgTEWorldDecal::unsafe_arena_release_normal() {
  // @@protoc_insertion_point(field_release:CMsgTEWorldDecal.normal)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgVector* temp = _impl_.normal_;
  _impl_.normal_ = nullptr;
  return temp;
}
inline ::CMsgVector* CMsgTEWorldDecal::_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* CMsgTEWorldDecal::mutable_normal() {
  ::CMsgVector* _msg = _internal_mutable_normal();
  // @@protoc_insertion_point(field_mutable:CMsgTEWorldDecal.normal)
  return _msg;
}
inline void CMsgTEWorldDecal::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:CMsgTEWorldDecal.normal)
}

// optional uint32 index = 3;
inline bool CMsgTEWorldDecal::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgTEWorldDecal::has_index() const {
  return _internal_has_index();
}
inline void CMsgTEWorldDecal::clear_index() {
  _impl_.index_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgTEWorldDecal::_internal_index() const {
  return _impl_.index_;
}
inline uint32_t CMsgTEWorldDecal::index() const {
  // @@protoc_insertion_point(field_get:CMsgTEWorldDecal.index)
  return _internal_index();
}
inline void CMsgTEWorldDecal::_internal_set_index(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.index_ = value;
}
inline void CMsgTEWorldDecal::set_index(uint32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:CMsgTEWorldDecal.index)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

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

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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