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

#ifndef GOOGLE_PROTOBUF_INCLUDED_usercmd_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_usercmd_2eproto

#include <limits>
#include <string>

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

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_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/unknown_field_set.h>
#include "networkbasetypes.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_usercmd_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_usercmd_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_usercmd_2eproto;
class CBaseUserCmdExecutionNotes;
struct CBaseUserCmdExecutionNotesDefaultTypeInternal;
extern CBaseUserCmdExecutionNotesDefaultTypeInternal _CBaseUserCmdExecutionNotes_default_instance_;
class CBaseUserCmdPB;
struct CBaseUserCmdPBDefaultTypeInternal;
extern CBaseUserCmdPBDefaultTypeInternal _CBaseUserCmdPB_default_instance_;
class CInButtonStatePB;
struct CInButtonStatePBDefaultTypeInternal;
extern CInButtonStatePBDefaultTypeInternal _CInButtonStatePB_default_instance_;
class CSubtickMoveStep;
struct CSubtickMoveStepDefaultTypeInternal;
extern CSubtickMoveStepDefaultTypeInternal _CSubtickMoveStep_default_instance_;
class CUserCmdBasePB;
struct CUserCmdBasePBDefaultTypeInternal;
extern CUserCmdBasePBDefaultTypeInternal _CUserCmdBasePB_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::CBaseUserCmdExecutionNotes* Arena::CreateMaybeMessage<::CBaseUserCmdExecutionNotes>(Arena*);
template<> ::CBaseUserCmdPB* Arena::CreateMaybeMessage<::CBaseUserCmdPB>(Arena*);
template<> ::CInButtonStatePB* Arena::CreateMaybeMessage<::CInButtonStatePB>(Arena*);
template<> ::CSubtickMoveStep* Arena::CreateMaybeMessage<::CSubtickMoveStep>(Arena*);
template<> ::CUserCmdBasePB* Arena::CreateMaybeMessage<::CUserCmdBasePB>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

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

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CInButtonStatePB";
  }
  protected:
  explicit CInButtonStatePB(::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 {
    kButtonstate1FieldNumber = 1,
    kButtonstate2FieldNumber = 2,
    kButtonstate3FieldNumber = 3,
  };
  // optional uint64 buttonstate1 = 1;
  bool has_buttonstate1() const;
  private:
  bool _internal_has_buttonstate1() const;
  public:
  void clear_buttonstate1();
  uint64_t buttonstate1() const;
  void set_buttonstate1(uint64_t value);
  private:
  uint64_t _internal_buttonstate1() const;
  void _internal_set_buttonstate1(uint64_t value);
  public:

  // optional uint64 buttonstate2 = 2;
  bool has_buttonstate2() const;
  private:
  bool _internal_has_buttonstate2() const;
  public:
  void clear_buttonstate2();
  uint64_t buttonstate2() const;
  void set_buttonstate2(uint64_t value);
  private:
  uint64_t _internal_buttonstate2() const;
  void _internal_set_buttonstate2(uint64_t value);
  public:

  // optional uint64 buttonstate3 = 3;
  bool has_buttonstate3() const;
  private:
  bool _internal_has_buttonstate3() const;
  public:
  void clear_buttonstate3();
  uint64_t buttonstate3() const;
  void set_buttonstate3(uint64_t value);
  private:
  uint64_t _internal_buttonstate3() const;
  void _internal_set_buttonstate3(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CInButtonStatePB)
 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 buttonstate1_;
    uint64_t buttonstate2_;
    uint64_t buttonstate3_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usercmd_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CSubtickMoveStep";
  }
  protected:
  explicit CSubtickMoveStep(::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 {
    kButtonFieldNumber = 1,
    kPressedFieldNumber = 2,
    kWhenFieldNumber = 3,
    kAnalogForwardDeltaFieldNumber = 4,
    kAnalogLeftDeltaFieldNumber = 5,
    kPitchDeltaFieldNumber = 8,
    kYawDeltaFieldNumber = 9,
  };
  // optional uint64 button = 1;
  bool has_button() const;
  private:
  bool _internal_has_button() const;
  public:
  void clear_button();
  uint64_t button() const;
  void set_button(uint64_t value);
  private:
  uint64_t _internal_button() const;
  void _internal_set_button(uint64_t value);
  public:

  // optional bool pressed = 2;
  bool has_pressed() const;
  private:
  bool _internal_has_pressed() const;
  public:
  void clear_pressed();
  bool pressed() const;
  void set_pressed(bool value);
  private:
  bool _internal_pressed() const;
  void _internal_set_pressed(bool value);
  public:

  // optional float when = 3;
  bool has_when() const;
  private:
  bool _internal_has_when() const;
  public:
  void clear_when();
  float when() const;
  void set_when(float value);
  private:
  float _internal_when() const;
  void _internal_set_when(float value);
  public:

  // optional float analog_forward_delta = 4;
  bool has_analog_forward_delta() const;
  private:
  bool _internal_has_analog_forward_delta() const;
  public:
  void clear_analog_forward_delta();
  float analog_forward_delta() const;
  void set_analog_forward_delta(float value);
  private:
  float _internal_analog_forward_delta() const;
  void _internal_set_analog_forward_delta(float value);
  public:

  // optional float analog_left_delta = 5;
  bool has_analog_left_delta() const;
  private:
  bool _internal_has_analog_left_delta() const;
  public:
  void clear_analog_left_delta();
  float analog_left_delta() const;
  void set_analog_left_delta(float value);
  private:
  float _internal_analog_left_delta() const;
  void _internal_set_analog_left_delta(float value);
  public:

  // optional float pitch_delta = 8;
  bool has_pitch_delta() const;
  private:
  bool _internal_has_pitch_delta() const;
  public:
  void clear_pitch_delta();
  float pitch_delta() const;
  void set_pitch_delta(float value);
  private:
  float _internal_pitch_delta() const;
  void _internal_set_pitch_delta(float value);
  public:

  // optional float yaw_delta = 9;
  bool has_yaw_delta() const;
  private:
  bool _internal_has_yaw_delta() const;
  public:
  void clear_yaw_delta();
  float yaw_delta() const;
  void set_yaw_delta(float value);
  private:
  float _internal_yaw_delta() const;
  void _internal_set_yaw_delta(float value);
  public:

  // @@protoc_insertion_point(class_scope:CSubtickMoveStep)
 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 button_;
    bool pressed_;
    float when_;
    float analog_forward_delta_;
    float analog_left_delta_;
    float pitch_delta_;
    float yaw_delta_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usercmd_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CBaseUserCmdExecutionNotes";
  }
  protected:
  explicit CBaseUserCmdExecutionNotes(::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 {
    kIgnoredReasonFieldNumber = 1,
  };
  // optional string ignored_reason = 1;
  bool has_ignored_reason() const;
  private:
  bool _internal_has_ignored_reason() const;
  public:
  void clear_ignored_reason();
  const std::string& ignored_reason() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ignored_reason(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ignored_reason();
  PROTOBUF_NODISCARD std::string* release_ignored_reason();
  void set_allocated_ignored_reason(std::string* ignored_reason);
  private:
  const std::string& _internal_ignored_reason() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ignored_reason(const std::string& value);
  std::string* _internal_mutable_ignored_reason();
  public:

  // @@protoc_insertion_point(class_scope:CBaseUserCmdExecutionNotes)
 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 ignored_reason_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usercmd_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CBaseUserCmdPB";
  }
  protected:
  explicit CBaseUserCmdPB(::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 {
    kSubtickMovesFieldNumber = 18,
    kMoveCrcFieldNumber = 19,
    kButtonsPbFieldNumber = 3,
    kViewanglesFieldNumber = 4,
    kExecutionNotesFieldNumber = 22,
    kLegacyCommandNumberFieldNumber = 1,
    kClientTickFieldNumber = 2,
    kForwardmoveFieldNumber = 5,
    kLeftmoveFieldNumber = 6,
    kUpmoveFieldNumber = 7,
    kImpulseFieldNumber = 8,
    kWeaponselectFieldNumber = 9,
    kRandomSeedFieldNumber = 10,
    kMousedxFieldNumber = 11,
    kMousedyFieldNumber = 12,
    kPredictionOffsetTicksX256FieldNumber = 17,
    kConsumedServerAngleChangesFieldNumber = 20,
    kCmdFlagsFieldNumber = 21,
    kPawnEntityHandleFieldNumber = 14,
  };
  // repeated .CSubtickMoveStep subtick_moves = 18;
  int subtick_moves_size() const;
  private:
  int _internal_subtick_moves_size() const;
  public:
  void clear_subtick_moves();
  ::CSubtickMoveStep* mutable_subtick_moves(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSubtickMoveStep >*
      mutable_subtick_moves();
  private:
  const ::CSubtickMoveStep& _internal_subtick_moves(int index) const;
  ::CSubtickMoveStep* _internal_add_subtick_moves();
  public:
  const ::CSubtickMoveStep& subtick_moves(int index) const;
  ::CSubtickMoveStep* add_subtick_moves();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSubtickMoveStep >&
      subtick_moves() const;

  // optional bytes move_crc = 19;
  bool has_move_crc() const;
  private:
  bool _internal_has_move_crc() const;
  public:
  void clear_move_crc();
  const std::string& move_crc() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_move_crc(ArgT0&& arg0, ArgT... args);
  std::string* mutable_move_crc();
  PROTOBUF_NODISCARD std::string* release_move_crc();
  void set_allocated_move_crc(std::string* move_crc);
  private:
  const std::string& _internal_move_crc() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_move_crc(const std::string& value);
  std::string* _internal_mutable_move_crc();
  public:

  // optional .CInButtonStatePB buttons_pb = 3;
  bool has_buttons_pb() const;
  private:
  bool _internal_has_buttons_pb() const;
  public:
  void clear_buttons_pb();
  const ::CInButtonStatePB& buttons_pb() const;
  PROTOBUF_NODISCARD ::CInButtonStatePB* release_buttons_pb();
  ::CInButtonStatePB* mutable_buttons_pb();
  void set_allocated_buttons_pb(::CInButtonStatePB* buttons_pb);
  private:
  const ::CInButtonStatePB& _internal_buttons_pb() const;
  ::CInButtonStatePB* _internal_mutable_buttons_pb();
  public:
  void unsafe_arena_set_allocated_buttons_pb(
      ::CInButtonStatePB* buttons_pb);
  ::CInButtonStatePB* unsafe_arena_release_buttons_pb();

  // optional .CMsgQAngle viewangles = 4;
  bool has_viewangles() const;
  private:
  bool _internal_has_viewangles() const;
  public:
  void clear_viewangles();
  const ::CMsgQAngle& viewangles() const;
  PROTOBUF_NODISCARD ::CMsgQAngle* release_viewangles();
  ::CMsgQAngle* mutable_viewangles();
  void set_allocated_viewangles(::CMsgQAngle* viewangles);
  private:
  const ::CMsgQAngle& _internal_viewangles() const;
  ::CMsgQAngle* _internal_mutable_viewangles();
  public:
  void unsafe_arena_set_allocated_viewangles(
      ::CMsgQAngle* viewangles);
  ::CMsgQAngle* unsafe_arena_release_viewangles();

  // optional .CBaseUserCmdExecutionNotes execution_notes = 22;
  bool has_execution_notes() const;
  private:
  bool _internal_has_execution_notes() const;
  public:
  void clear_execution_notes();
  const ::CBaseUserCmdExecutionNotes& execution_notes() const;
  PROTOBUF_NODISCARD ::CBaseUserCmdExecutionNotes* release_execution_notes();
  ::CBaseUserCmdExecutionNotes* mutable_execution_notes();
  void set_allocated_execution_notes(::CBaseUserCmdExecutionNotes* execution_notes);
  private:
  const ::CBaseUserCmdExecutionNotes& _internal_execution_notes() const;
  ::CBaseUserCmdExecutionNotes* _internal_mutable_execution_notes();
  public:
  void unsafe_arena_set_allocated_execution_notes(
      ::CBaseUserCmdExecutionNotes* execution_notes);
  ::CBaseUserCmdExecutionNotes* unsafe_arena_release_execution_notes();

  // optional int32 legacy_command_number = 1;
  bool has_legacy_command_number() const;
  private:
  bool _internal_has_legacy_command_number() const;
  public:
  void clear_legacy_command_number();
  int32_t legacy_command_number() const;
  void set_legacy_command_number(int32_t value);
  private:
  int32_t _internal_legacy_command_number() const;
  void _internal_set_legacy_command_number(int32_t value);
  public:

  // optional int32 client_tick = 2;
  bool has_client_tick() const;
  private:
  bool _internal_has_client_tick() const;
  public:
  void clear_client_tick();
  int32_t client_tick() const;
  void set_client_tick(int32_t value);
  private:
  int32_t _internal_client_tick() const;
  void _internal_set_client_tick(int32_t value);
  public:

  // optional float forwardmove = 5;
  bool has_forwardmove() const;
  private:
  bool _internal_has_forwardmove() const;
  public:
  void clear_forwardmove();
  float forwardmove() const;
  void set_forwardmove(float value);
  private:
  float _internal_forwardmove() const;
  void _internal_set_forwardmove(float value);
  public:

  // optional float leftmove = 6;
  bool has_leftmove() const;
  private:
  bool _internal_has_leftmove() const;
  public:
  void clear_leftmove();
  float leftmove() const;
  void set_leftmove(float value);
  private:
  float _internal_leftmove() const;
  void _internal_set_leftmove(float value);
  public:

  // optional float upmove = 7;
  bool has_upmove() const;
  private:
  bool _internal_has_upmove() const;
  public:
  void clear_upmove();
  float upmove() const;
  void set_upmove(float value);
  private:
  float _internal_upmove() const;
  void _internal_set_upmove(float value);
  public:

  // optional int32 impulse = 8;
  bool has_impulse() const;
  private:
  bool _internal_has_impulse() const;
  public:
  void clear_impulse();
  int32_t impulse() const;
  void set_impulse(int32_t value);
  private:
  int32_t _internal_impulse() const;
  void _internal_set_impulse(int32_t value);
  public:

  // optional int32 weaponselect = 9;
  bool has_weaponselect() const;
  private:
  bool _internal_has_weaponselect() const;
  public:
  void clear_weaponselect();
  int32_t weaponselect() const;
  void set_weaponselect(int32_t value);
  private:
  int32_t _internal_weaponselect() const;
  void _internal_set_weaponselect(int32_t value);
  public:

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

  // optional int32 mousedx = 11;
  bool has_mousedx() const;
  private:
  bool _internal_has_mousedx() const;
  public:
  void clear_mousedx();
  int32_t mousedx() const;
  void set_mousedx(int32_t value);
  private:
  int32_t _internal_mousedx() const;
  void _internal_set_mousedx(int32_t value);
  public:

  // optional int32 mousedy = 12;
  bool has_mousedy() const;
  private:
  bool _internal_has_mousedy() const;
  public:
  void clear_mousedy();
  int32_t mousedy() const;
  void set_mousedy(int32_t value);
  private:
  int32_t _internal_mousedy() const;
  void _internal_set_mousedy(int32_t value);
  public:

  // optional uint32 prediction_offset_ticks_x256 = 17;
  bool has_prediction_offset_ticks_x256() const;
  private:
  bool _internal_has_prediction_offset_ticks_x256() const;
  public:
  void clear_prediction_offset_ticks_x256();
  uint32_t prediction_offset_ticks_x256() const;
  void set_prediction_offset_ticks_x256(uint32_t value);
  private:
  uint32_t _internal_prediction_offset_ticks_x256() const;
  void _internal_set_prediction_offset_ticks_x256(uint32_t value);
  public:

  // optional uint32 consumed_server_angle_changes = 20;
  bool has_consumed_server_angle_changes() const;
  private:
  bool _internal_has_consumed_server_angle_changes() const;
  public:
  void clear_consumed_server_angle_changes();
  uint32_t consumed_server_angle_changes() const;
  void set_consumed_server_angle_changes(uint32_t value);
  private:
  uint32_t _internal_consumed_server_angle_changes() const;
  void _internal_set_consumed_server_angle_changes(uint32_t value);
  public:

  // optional int32 cmd_flags = 21;
  bool has_cmd_flags() const;
  private:
  bool _internal_has_cmd_flags() const;
  public:
  void clear_cmd_flags();
  int32_t cmd_flags() const;
  void set_cmd_flags(int32_t value);
  private:
  int32_t _internal_cmd_flags() const;
  void _internal_set_cmd_flags(int32_t value);
  public:

  // optional uint32 pawn_entity_handle = 14 [default = 16777215];
  bool has_pawn_entity_handle() const;
  private:
  bool _internal_has_pawn_entity_handle() const;
  public:
  void clear_pawn_entity_handle();
  uint32_t pawn_entity_handle() const;
  void set_pawn_entity_handle(uint32_t value);
  private:
  uint32_t _internal_pawn_entity_handle() const;
  void _internal_set_pawn_entity_handle(uint32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSubtickMoveStep > subtick_moves_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr move_crc_;
    ::CInButtonStatePB* buttons_pb_;
    ::CMsgQAngle* viewangles_;
    ::CBaseUserCmdExecutionNotes* execution_notes_;
    int32_t legacy_command_number_;
    int32_t client_tick_;
    float forwardmove_;
    float leftmove_;
    float upmove_;
    int32_t impulse_;
    int32_t weaponselect_;
    int32_t random_seed_;
    int32_t mousedx_;
    int32_t mousedy_;
    uint32_t prediction_offset_ticks_x256_;
    uint32_t consumed_server_angle_changes_;
    int32_t cmd_flags_;
    uint32_t pawn_entity_handle_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usercmd_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  // @@protoc_insertion_point(class_scope:CUserCmdBasePB)
 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_;
    ::CBaseUserCmdPB* base_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_usercmd_2eproto;
};
// ===================================================================


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

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

// optional uint64 buttonstate1 = 1;
inline bool CInButtonStatePB::_internal_has_buttonstate1() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CInButtonStatePB::has_buttonstate1() const {
  return _internal_has_buttonstate1();
}
inline void CInButtonStatePB::clear_buttonstate1() {
  _impl_.buttonstate1_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CInButtonStatePB::_internal_buttonstate1() const {
  return _impl_.buttonstate1_;
}
inline uint64_t CInButtonStatePB::buttonstate1() const {
  // @@protoc_insertion_point(field_get:CInButtonStatePB.buttonstate1)
  return _internal_buttonstate1();
}
inline void CInButtonStatePB::_internal_set_buttonstate1(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.buttonstate1_ = value;
}
inline void CInButtonStatePB::set_buttonstate1(uint64_t value) {
  _internal_set_buttonstate1(value);
  // @@protoc_insertion_point(field_set:CInButtonStatePB.buttonstate1)
}

// optional uint64 buttonstate2 = 2;
inline bool CInButtonStatePB::_internal_has_buttonstate2() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CInButtonStatePB::has_buttonstate2() const {
  return _internal_has_buttonstate2();
}
inline void CInButtonStatePB::clear_buttonstate2() {
  _impl_.buttonstate2_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CInButtonStatePB::_internal_buttonstate2() const {
  return _impl_.buttonstate2_;
}
inline uint64_t CInButtonStatePB::buttonstate2() const {
  // @@protoc_insertion_point(field_get:CInButtonStatePB.buttonstate2)
  return _internal_buttonstate2();
}
inline void CInButtonStatePB::_internal_set_buttonstate2(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.buttonstate2_ = value;
}
inline void CInButtonStatePB::set_buttonstate2(uint64_t value) {
  _internal_set_buttonstate2(value);
  // @@protoc_insertion_point(field_set:CInButtonStatePB.buttonstate2)
}

// optional uint64 buttonstate3 = 3;
inline bool CInButtonStatePB::_internal_has_buttonstate3() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CInButtonStatePB::has_buttonstate3() const {
  return _internal_has_buttonstate3();
}
inline void CInButtonStatePB::clear_buttonstate3() {
  _impl_.buttonstate3_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CInButtonStatePB::_internal_buttonstate3() const {
  return _impl_.buttonstate3_;
}
inline uint64_t CInButtonStatePB::buttonstate3() const {
  // @@protoc_insertion_point(field_get:CInButtonStatePB.buttonstate3)
  return _internal_buttonstate3();
}
inline void CInButtonStatePB::_internal_set_buttonstate3(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.buttonstate3_ = value;
}
inline void CInButtonStatePB::set_buttonstate3(uint64_t value) {
  _internal_set_buttonstate3(value);
  // @@protoc_insertion_point(field_set:CInButtonStatePB.buttonstate3)
}

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

// CSubtickMoveStep

// optional uint64 button = 1;
inline bool CSubtickMoveStep::_internal_has_button() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CSubtickMoveStep::has_button() const {
  return _internal_has_button();
}
inline void CSubtickMoveStep::clear_button() {
  _impl_.button_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CSubtickMoveStep::_internal_button() const {
  return _impl_.button_;
}
inline uint64_t CSubtickMoveStep::button() const {
  // @@protoc_insertion_point(field_get:CSubtickMoveStep.button)
  return _internal_button();
}
inline void CSubtickMoveStep::_internal_set_button(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.button_ = value;
}
inline void CSubtickMoveStep::set_button(uint64_t value) {
  _internal_set_button(value);
  // @@protoc_insertion_point(field_set:CSubtickMoveStep.button)
}

// optional bool pressed = 2;
inline bool CSubtickMoveStep::_internal_has_pressed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CSubtickMoveStep::has_pressed() const {
  return _internal_has_pressed();
}
inline void CSubtickMoveStep::clear_pressed() {
  _impl_.pressed_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CSubtickMoveStep::_internal_pressed() const {
  return _impl_.pressed_;
}
inline bool CSubtickMoveStep::pressed() const {
  // @@protoc_insertion_point(field_get:CSubtickMoveStep.pressed)
  return _internal_pressed();
}
inline void CSubtickMoveStep::_internal_set_pressed(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.pressed_ = value;
}
inline void CSubtickMoveStep::set_pressed(bool value) {
  _internal_set_pressed(value);
  // @@protoc_insertion_point(field_set:CSubtickMoveStep.pressed)
}

// optional float when = 3;
inline bool CSubtickMoveStep::_internal_has_when() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CSubtickMoveStep::has_when() const {
  return _internal_has_when();
}
inline void CSubtickMoveStep::clear_when() {
  _impl_.when_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline float CSubtickMoveStep::_internal_when() const {
  return _impl_.when_;
}
inline float CSubtickMoveStep::when() const {
  // @@protoc_insertion_point(field_get:CSubtickMoveStep.when)
  return _internal_when();
}
inline void CSubtickMoveStep::_internal_set_when(float value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.when_ = value;
}
inline void CSubtickMoveStep::set_when(float value) {
  _internal_set_when(value);
  // @@protoc_insertion_point(field_set:CSubtickMoveStep.when)
}

// optional float analog_forward_delta = 4;
inline bool CSubtickMoveStep::_internal_has_analog_forward_delta() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CSubtickMoveStep::has_analog_forward_delta() const {
  return _internal_has_analog_forward_delta();
}
inline void CSubtickMoveStep::clear_analog_forward_delta() {
  _impl_.analog_forward_delta_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline float CSubtickMoveStep::_internal_analog_forward_delta() const {
  return _impl_.analog_forward_delta_;
}
inline float CSubtickMoveStep::analog_forward_delta() const {
  // @@protoc_insertion_point(field_get:CSubtickMoveStep.analog_forward_delta)
  return _internal_analog_forward_delta();
}
inline void CSubtickMoveStep::_internal_set_analog_forward_delta(float value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.analog_forward_delta_ = value;
}
inline void CSubtickMoveStep::set_analog_forward_delta(float value) {
  _internal_set_analog_forward_delta(value);
  // @@protoc_insertion_point(field_set:CSubtickMoveStep.analog_forward_delta)
}

// optional float analog_left_delta = 5;
inline bool CSubtickMoveStep::_internal_has_analog_left_delta() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CSubtickMoveStep::has_analog_left_delta() const {
  return _internal_has_analog_left_delta();
}
inline void CSubtickMoveStep::clear_analog_left_delta() {
  _impl_.analog_left_delta_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline float CSubtickMoveStep::_internal_analog_left_delta() const {
  return _impl_.analog_left_delta_;
}
inline float CSubtickMoveStep::analog_left_delta() const {
  // @@protoc_insertion_point(field_get:CSubtickMoveStep.analog_left_delta)
  return _internal_analog_left_delta();
}
inline void CSubtickMoveStep::_internal_set_analog_left_delta(float value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.analog_left_delta_ = value;
}
inline void CSubtickMoveStep::set_analog_left_delta(float value) {
  _internal_set_analog_left_delta(value);
  // @@protoc_insertion_point(field_set:CSubtickMoveStep.analog_left_delta)
}

// optional float pitch_delta = 8;
inline bool CSubtickMoveStep::_internal_has_pitch_delta() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CSubtickMoveStep::has_pitch_delta() const {
  return _internal_has_pitch_delta();
}
inline void CSubtickMoveStep::clear_pitch_delta() {
  _impl_.pitch_delta_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline float CSubtickMoveStep::_internal_pitch_delta() const {
  return _impl_.pitch_delta_;
}
inline float CSubtickMoveStep::pitch_delta() const {
  // @@protoc_insertion_point(field_get:CSubtickMoveStep.pitch_delta)
  return _internal_pitch_delta();
}
inline void CSubtickMoveStep::_internal_set_pitch_delta(float value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.pitch_delta_ = value;
}
inline void CSubtickMoveStep::set_pitch_delta(float value) {
  _internal_set_pitch_delta(value);
  // @@protoc_insertion_point(field_set:CSubtickMoveStep.pitch_delta)
}

// optional float yaw_delta = 9;
inline bool CSubtickMoveStep::_internal_has_yaw_delta() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CSubtickMoveStep::has_yaw_delta() const {
  return _internal_has_yaw_delta();
}
inline void CSubtickMoveStep::clear_yaw_delta() {
  _impl_.yaw_delta_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float CSubtickMoveStep::_internal_yaw_delta() const {
  return _impl_.yaw_delta_;
}
inline float CSubtickMoveStep::yaw_delta() const {
  // @@protoc_insertion_point(field_get:CSubtickMoveStep.yaw_delta)
  return _internal_yaw_delta();
}
inline void CSubtickMoveStep::_internal_set_yaw_delta(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.yaw_delta_ = value;
}
inline void CSubtickMoveStep::set_yaw_delta(float value) {
  _internal_set_yaw_delta(value);
  // @@protoc_insertion_point(field_set:CSubtickMoveStep.yaw_delta)
}

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

// CBaseUserCmdExecutionNotes

// optional string ignored_reason = 1;
inline bool CBaseUserCmdExecutionNotes::_internal_has_ignored_reason() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CBaseUserCmdExecutionNotes::has_ignored_reason() const {
  return _internal_has_ignored_reason();
}
inline void CBaseUserCmdExecutionNotes::clear_ignored_reason() {
  _impl_.ignored_reason_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CBaseUserCmdExecutionNotes::ignored_reason() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdExecutionNotes.ignored_reason)
  return _internal_ignored_reason();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CBaseUserCmdExecutionNotes::set_ignored_reason(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.ignored_reason_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CBaseUserCmdExecutionNotes.ignored_reason)
}
inline std::string* CBaseUserCmdExecutionNotes::mutable_ignored_reason() {
  std::string* _s = _internal_mutable_ignored_reason();
  // @@protoc_insertion_point(field_mutable:CBaseUserCmdExecutionNotes.ignored_reason)
  return _s;
}
inline const std::string& CBaseUserCmdExecutionNotes::_internal_ignored_reason() const {
  return _impl_.ignored_reason_.Get();
}
inline void CBaseUserCmdExecutionNotes::_internal_set_ignored_reason(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.ignored_reason_.Set(value, GetArenaForAllocation());
}
inline std::string* CBaseUserCmdExecutionNotes::_internal_mutable_ignored_reason() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.ignored_reason_.Mutable(GetArenaForAllocation());
}
inline std::string* CBaseUserCmdExecutionNotes::release_ignored_reason() {
  // @@protoc_insertion_point(field_release:CBaseUserCmdExecutionNotes.ignored_reason)
  if (!_internal_has_ignored_reason()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.ignored_reason_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ignored_reason_.IsDefault()) {
    _impl_.ignored_reason_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CBaseUserCmdExecutionNotes::set_allocated_ignored_reason(std::string* ignored_reason) {
  if (ignored_reason != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.ignored_reason_.SetAllocated(ignored_reason, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ignored_reason_.IsDefault()) {
    _impl_.ignored_reason_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CBaseUserCmdExecutionNotes.ignored_reason)
}

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

// CBaseUserCmdPB

// optional int32 legacy_command_number = 1;
inline bool CBaseUserCmdPB::_internal_has_legacy_command_number() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CBaseUserCmdPB::has_legacy_command_number() const {
  return _internal_has_legacy_command_number();
}
inline void CBaseUserCmdPB::clear_legacy_command_number() {
  _impl_.legacy_command_number_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t CBaseUserCmdPB::_internal_legacy_command_number() const {
  return _impl_.legacy_command_number_;
}
inline int32_t CBaseUserCmdPB::legacy_command_number() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.legacy_command_number)
  return _internal_legacy_command_number();
}
inline void CBaseUserCmdPB::_internal_set_legacy_command_number(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.legacy_command_number_ = value;
}
inline void CBaseUserCmdPB::set_legacy_command_number(int32_t value) {
  _internal_set_legacy_command_number(value);
  // @@protoc_insertion_point(field_set:CBaseUserCmdPB.legacy_command_number)
}

// optional int32 client_tick = 2;
inline bool CBaseUserCmdPB::_internal_has_client_tick() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CBaseUserCmdPB::has_client_tick() const {
  return _internal_has_client_tick();
}
inline void CBaseUserCmdPB::clear_client_tick() {
  _impl_.client_tick_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t CBaseUserCmdPB::_internal_client_tick() const {
  return _impl_.client_tick_;
}
inline int32_t CBaseUserCmdPB::client_tick() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.client_tick)
  return _internal_client_tick();
}
inline void CBaseUserCmdPB::_internal_set_client_tick(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.client_tick_ = value;
}
inline void CBaseUserCmdPB::set_client_tick(int32_t value) {
  _internal_set_client_tick(value);
  // @@protoc_insertion_point(field_set:CBaseUserCmdPB.client_tick)
}

// optional uint32 prediction_offset_ticks_x256 = 17;
inline bool CBaseUserCmdPB::_internal_has_prediction_offset_ticks_x256() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CBaseUserCmdPB::has_prediction_offset_ticks_x256() const {
  return _internal_has_prediction_offset_ticks_x256();
}
inline void CBaseUserCmdPB::clear_prediction_offset_ticks_x256() {
  _impl_.prediction_offset_ticks_x256_ = 0u;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint32_t CBaseUserCmdPB::_internal_prediction_offset_ticks_x256() const {
  return _impl_.prediction_offset_ticks_x256_;
}
inline uint32_t CBaseUserCmdPB::prediction_offset_ticks_x256() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.prediction_offset_ticks_x256)
  return _internal_prediction_offset_ticks_x256();
}
inline void CBaseUserCmdPB::_internal_set_prediction_offset_ticks_x256(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.prediction_offset_ticks_x256_ = value;
}
inline void CBaseUserCmdPB::set_prediction_offset_ticks_x256(uint32_t value) {
  _internal_set_prediction_offset_ticks_x256(value);
  // @@protoc_insertion_point(field_set:CBaseUserCmdPB.prediction_offset_ticks_x256)
}

// optional .CInButtonStatePB buttons_pb = 3;
inline bool CBaseUserCmdPB::_internal_has_buttons_pb() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.buttons_pb_ != nullptr);
  return value;
}
inline bool CBaseUserCmdPB::has_buttons_pb() const {
  return _internal_has_buttons_pb();
}
inline void CBaseUserCmdPB::clear_buttons_pb() {
  if (_impl_.buttons_pb_ != nullptr) _impl_.buttons_pb_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::CInButtonStatePB& CBaseUserCmdPB::_internal_buttons_pb() const {
  const ::CInButtonStatePB* p = _impl_.buttons_pb_;
  return p != nullptr ? *p : reinterpret_cast<const ::CInButtonStatePB&>(
      ::_CInButtonStatePB_default_instance_);
}
inline const ::CInButtonStatePB& CBaseUserCmdPB::buttons_pb() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.buttons_pb)
  return _internal_buttons_pb();
}
inline void CBaseUserCmdPB::unsafe_arena_set_allocated_buttons_pb(
    ::CInButtonStatePB* buttons_pb) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buttons_pb_);
  }
  _impl_.buttons_pb_ = buttons_pb;
  if (buttons_pb) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CBaseUserCmdPB.buttons_pb)
}
inline ::CInButtonStatePB* CBaseUserCmdPB::release_buttons_pb() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CInButtonStatePB* temp = _impl_.buttons_pb_;
  _impl_.buttons_pb_ = 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 ::CInButtonStatePB* CBaseUserCmdPB::unsafe_arena_release_buttons_pb() {
  // @@protoc_insertion_point(field_release:CBaseUserCmdPB.buttons_pb)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CInButtonStatePB* temp = _impl_.buttons_pb_;
  _impl_.buttons_pb_ = nullptr;
  return temp;
}
inline ::CInButtonStatePB* CBaseUserCmdPB::_internal_mutable_buttons_pb() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.buttons_pb_ == nullptr) {
    auto* p = CreateMaybeMessage<::CInButtonStatePB>(GetArenaForAllocation());
    _impl_.buttons_pb_ = p;
  }
  return _impl_.buttons_pb_;
}
inline ::CInButtonStatePB* CBaseUserCmdPB::mutable_buttons_pb() {
  ::CInButtonStatePB* _msg = _internal_mutable_buttons_pb();
  // @@protoc_insertion_point(field_mutable:CBaseUserCmdPB.buttons_pb)
  return _msg;
}
inline void CBaseUserCmdPB::set_allocated_buttons_pb(::CInButtonStatePB* buttons_pb) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.buttons_pb_;
  }
  if (buttons_pb) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(buttons_pb);
    if (message_arena != submessage_arena) {
      buttons_pb = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, buttons_pb, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.buttons_pb_ = buttons_pb;
  // @@protoc_insertion_point(field_set_allocated:CBaseUserCmdPB.buttons_pb)
}

// optional .CMsgQAngle viewangles = 4;
inline bool CBaseUserCmdPB::_internal_has_viewangles() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.viewangles_ != nullptr);
  return value;
}
inline bool CBaseUserCmdPB::has_viewangles() const {
  return _internal_has_viewangles();
}
inline const ::CMsgQAngle& CBaseUserCmdPB::_internal_viewangles() const {
  const ::CMsgQAngle* p = _impl_.viewangles_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgQAngle&>(
      ::_CMsgQAngle_default_instance_);
}
inline const ::CMsgQAngle& CBaseUserCmdPB::viewangles() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.viewangles)
  return _internal_viewangles();
}
inline void CBaseUserCmdPB::unsafe_arena_set_allocated_viewangles(
    ::CMsgQAngle* viewangles) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.viewangles_);
  }
  _impl_.viewangles_ = viewangles;
  if (viewangles) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CBaseUserCmdPB.viewangles)
}
inline ::CMsgQAngle* CBaseUserCmdPB::release_viewangles() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgQAngle* temp = _impl_.viewangles_;
  _impl_.viewangles_ = 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* CBaseUserCmdPB::unsafe_arena_release_viewangles() {
  // @@protoc_insertion_point(field_release:CBaseUserCmdPB.viewangles)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgQAngle* temp = _impl_.viewangles_;
  _impl_.viewangles_ = nullptr;
  return temp;
}
inline ::CMsgQAngle* CBaseUserCmdPB::_internal_mutable_viewangles() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.viewangles_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgQAngle>(GetArenaForAllocation());
    _impl_.viewangles_ = p;
  }
  return _impl_.viewangles_;
}
inline ::CMsgQAngle* CBaseUserCmdPB::mutable_viewangles() {
  ::CMsgQAngle* _msg = _internal_mutable_viewangles();
  // @@protoc_insertion_point(field_mutable:CBaseUserCmdPB.viewangles)
  return _msg;
}
inline void CBaseUserCmdPB::set_allocated_viewangles(::CMsgQAngle* viewangles) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.viewangles_);
  }
  if (viewangles) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(viewangles));
    if (message_arena != submessage_arena) {
      viewangles = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, viewangles, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.viewangles_ = viewangles;
  // @@protoc_insertion_point(field_set_allocated:CBaseUserCmdPB.viewangles)
}

// optional float forwardmove = 5;
inline bool CBaseUserCmdPB::_internal_has_forwardmove() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CBaseUserCmdPB::has_forwardmove() const {
  return _internal_has_forwardmove();
}
inline void CBaseUserCmdPB::clear_forwardmove() {
  _impl_.forwardmove_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float CBaseUserCmdPB::_internal_forwardmove() const {
  return _impl_.forwardmove_;
}
inline float CBaseUserCmdPB::forwardmove() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.forwardmove)
  return _internal_forwardmove();
}
inline void CBaseUserCmdPB::_internal_set_forwardmove(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.forwardmove_ = value;
}
inline void CBaseUserCmdPB::set_forwardmove(float value) {
  _internal_set_forwardmove(value);
  // @@protoc_insertion_point(field_set:CBaseUserCmdPB.forwardmove)
}

// optional float leftmove = 6;
inline bool CBaseUserCmdPB::_internal_has_leftmove() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CBaseUserCmdPB::has_leftmove() const {
  return _internal_has_leftmove();
}
inline void CBaseUserCmdPB::clear_leftmove() {
  _impl_.leftmove_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline float CBaseUserCmdPB::_internal_leftmove() const {
  return _impl_.leftmove_;
}
inline float CBaseUserCmdPB::leftmove() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.leftmove)
  return _internal_leftmove();
}
inline void CBaseUserCmdPB::_internal_set_leftmove(float value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.leftmove_ = value;
}
inline void CBaseUserCmdPB::set_leftmove(float value) {
  _internal_set_leftmove(value);
  // @@protoc_insertion_point(field_set:CBaseUserCmdPB.leftmove)
}

// optional float upmove = 7;
inline bool CBaseUserCmdPB::_internal_has_upmove() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CBaseUserCmdPB::has_upmove() const {
  return _internal_has_upmove();
}
inline void CBaseUserCmdPB::clear_upmove() {
  _impl_.upmove_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline float CBaseUserCmdPB::_internal_upmove() const {
  return _impl_.upmove_;
}
inline float CBaseUserCmdPB::upmove() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.upmove)
  return _internal_upmove();
}
inline void CBaseUserCmdPB::_internal_set_upmove(float value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.upmove_ = value;
}
inline void CBaseUserCmdPB::set_upmove(float value) {
  _internal_set_upmove(value);
  // @@protoc_insertion_point(field_set:CBaseUserCmdPB.upmove)
}

// optional int32 impulse = 8;
inline bool CBaseUserCmdPB::_internal_has_impulse() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CBaseUserCmdPB::has_impulse() const {
  return _internal_has_impulse();
}
inline void CBaseUserCmdPB::clear_impulse() {
  _impl_.impulse_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t CBaseUserCmdPB::_internal_impulse() const {
  return _impl_.impulse_;
}
inline int32_t CBaseUserCmdPB::impulse() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.impulse)
  return _internal_impulse();
}
inline void CBaseUserCmdPB::_internal_set_impulse(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.impulse_ = value;
}
inline void CBaseUserCmdPB::set_impulse(int32_t value) {
  _internal_set_impulse(value);
  // @@protoc_insertion_point(field_set:CBaseUserCmdPB.impulse)
}

// optional int32 weaponselect = 9;
inline bool CBaseUserCmdPB::_internal_has_weaponselect() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CBaseUserCmdPB::has_weaponselect() const {
  return _internal_has_weaponselect();
}
inline void CBaseUserCmdPB::clear_weaponselect() {
  _impl_.weaponselect_ = 0;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline int32_t CBaseUserCmdPB::_internal_weaponselect() const {
  return _impl_.weaponselect_;
}
inline int32_t CBaseUserCmdPB::weaponselect() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.weaponselect)
  return _internal_weaponselect();
}
inline void CBaseUserCmdPB::_internal_set_weaponselect(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.weaponselect_ = value;
}
inline void CBaseUserCmdPB::set_weaponselect(int32_t value) {
  _internal_set_weaponselect(value);
  // @@protoc_insertion_point(field_set:CBaseUserCmdPB.weaponselect)
}

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

// optional int32 mousedx = 11;
inline bool CBaseUserCmdPB::_internal_has_mousedx() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CBaseUserCmdPB::has_mousedx() const {
  return _internal_has_mousedx();
}
inline void CBaseUserCmdPB::clear_mousedx() {
  _impl_.mousedx_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline int32_t CBaseUserCmdPB::_internal_mousedx() const {
  return _impl_.mousedx_;
}
inline int32_t CBaseUserCmdPB::mousedx() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.mousedx)
  return _internal_mousedx();
}
inline void CBaseUserCmdPB::_internal_set_mousedx(int32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.mousedx_ = value;
}
inline void CBaseUserCmdPB::set_mousedx(int32_t value) {
  _internal_set_mousedx(value);
  // @@protoc_insertion_point(field_set:CBaseUserCmdPB.mousedx)
}

// optional int32 mousedy = 12;
inline bool CBaseUserCmdPB::_internal_has_mousedy() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CBaseUserCmdPB::has_mousedy() const {
  return _internal_has_mousedy();
}
inline void CBaseUserCmdPB::clear_mousedy() {
  _impl_.mousedy_ = 0;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline int32_t CBaseUserCmdPB::_internal_mousedy() const {
  return _impl_.mousedy_;
}
inline int32_t CBaseUserCmdPB::mousedy() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.mousedy)
  return _internal_mousedy();
}
inline void CBaseUserCmdPB::_internal_set_mousedy(int32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.mousedy_ = value;
}
inline void CBaseUserCmdPB::set_mousedy(int32_t value) {
  _internal_set_mousedy(value);
  // @@protoc_insertion_point(field_set:CBaseUserCmdPB.mousedy)
}

// optional uint32 pawn_entity_handle = 14 [default = 16777215];
inline bool CBaseUserCmdPB::_internal_has_pawn_entity_handle() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool CBaseUserCmdPB::has_pawn_entity_handle() const {
  return _internal_has_pawn_entity_handle();
}
inline void CBaseUserCmdPB::clear_pawn_entity_handle() {
  _impl_.pawn_entity_handle_ = 16777215u;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline uint32_t CBaseUserCmdPB::_internal_pawn_entity_handle() const {
  return _impl_.pawn_entity_handle_;
}
inline uint32_t CBaseUserCmdPB::pawn_entity_handle() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.pawn_entity_handle)
  return _internal_pawn_entity_handle();
}
inline void CBaseUserCmdPB::_internal_set_pawn_entity_handle(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.pawn_entity_handle_ = value;
}
inline void CBaseUserCmdPB::set_pawn_entity_handle(uint32_t value) {
  _internal_set_pawn_entity_handle(value);
  // @@protoc_insertion_point(field_set:CBaseUserCmdPB.pawn_entity_handle)
}

// repeated .CSubtickMoveStep subtick_moves = 18;
inline int CBaseUserCmdPB::_internal_subtick_moves_size() const {
  return _impl_.subtick_moves_.size();
}
inline int CBaseUserCmdPB::subtick_moves_size() const {
  return _internal_subtick_moves_size();
}
inline void CBaseUserCmdPB::clear_subtick_moves() {
  _impl_.subtick_moves_.Clear();
}
inline ::CSubtickMoveStep* CBaseUserCmdPB::mutable_subtick_moves(int index) {
  // @@protoc_insertion_point(field_mutable:CBaseUserCmdPB.subtick_moves)
  return _impl_.subtick_moves_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSubtickMoveStep >*
CBaseUserCmdPB::mutable_subtick_moves() {
  // @@protoc_insertion_point(field_mutable_list:CBaseUserCmdPB.subtick_moves)
  return &_impl_.subtick_moves_;
}
inline const ::CSubtickMoveStep& CBaseUserCmdPB::_internal_subtick_moves(int index) const {
  return _impl_.subtick_moves_.Get(index);
}
inline const ::CSubtickMoveStep& CBaseUserCmdPB::subtick_moves(int index) const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.subtick_moves)
  return _internal_subtick_moves(index);
}
inline ::CSubtickMoveStep* CBaseUserCmdPB::_internal_add_subtick_moves() {
  return _impl_.subtick_moves_.Add();
}
inline ::CSubtickMoveStep* CBaseUserCmdPB::add_subtick_moves() {
  ::CSubtickMoveStep* _add = _internal_add_subtick_moves();
  // @@protoc_insertion_point(field_add:CBaseUserCmdPB.subtick_moves)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CSubtickMoveStep >&
CBaseUserCmdPB::subtick_moves() const {
  // @@protoc_insertion_point(field_list:CBaseUserCmdPB.subtick_moves)
  return _impl_.subtick_moves_;
}

// optional bytes move_crc = 19;
inline bool CBaseUserCmdPB::_internal_has_move_crc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CBaseUserCmdPB::has_move_crc() const {
  return _internal_has_move_crc();
}
inline void CBaseUserCmdPB::clear_move_crc() {
  _impl_.move_crc_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CBaseUserCmdPB::move_crc() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.move_crc)
  return _internal_move_crc();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CBaseUserCmdPB::set_move_crc(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.move_crc_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CBaseUserCmdPB.move_crc)
}
inline std::string* CBaseUserCmdPB::mutable_move_crc() {
  std::string* _s = _internal_mutable_move_crc();
  // @@protoc_insertion_point(field_mutable:CBaseUserCmdPB.move_crc)
  return _s;
}
inline const std::string& CBaseUserCmdPB::_internal_move_crc() const {
  return _impl_.move_crc_.Get();
}
inline void CBaseUserCmdPB::_internal_set_move_crc(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.move_crc_.Set(value, GetArenaForAllocation());
}
inline std::string* CBaseUserCmdPB::_internal_mutable_move_crc() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.move_crc_.Mutable(GetArenaForAllocation());
}
inline std::string* CBaseUserCmdPB::release_move_crc() {
  // @@protoc_insertion_point(field_release:CBaseUserCmdPB.move_crc)
  if (!_internal_has_move_crc()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.move_crc_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.move_crc_.IsDefault()) {
    _impl_.move_crc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CBaseUserCmdPB::set_allocated_move_crc(std::string* move_crc) {
  if (move_crc != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.move_crc_.SetAllocated(move_crc, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.move_crc_.IsDefault()) {
    _impl_.move_crc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CBaseUserCmdPB.move_crc)
}

// optional uint32 consumed_server_angle_changes = 20;
inline bool CBaseUserCmdPB::_internal_has_consumed_server_angle_changes() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool CBaseUserCmdPB::has_consumed_server_angle_changes() const {
  return _internal_has_consumed_server_angle_changes();
}
inline void CBaseUserCmdPB::clear_consumed_server_angle_changes() {
  _impl_.consumed_server_angle_changes_ = 0u;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline uint32_t CBaseUserCmdPB::_internal_consumed_server_angle_changes() const {
  return _impl_.consumed_server_angle_changes_;
}
inline uint32_t CBaseUserCmdPB::consumed_server_angle_changes() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.consumed_server_angle_changes)
  return _internal_consumed_server_angle_changes();
}
inline void CBaseUserCmdPB::_internal_set_consumed_server_angle_changes(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.consumed_server_angle_changes_ = value;
}
inline void CBaseUserCmdPB::set_consumed_server_angle_changes(uint32_t value) {
  _internal_set_consumed_server_angle_changes(value);
  // @@protoc_insertion_point(field_set:CBaseUserCmdPB.consumed_server_angle_changes)
}

// optional int32 cmd_flags = 21;
inline bool CBaseUserCmdPB::_internal_has_cmd_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool CBaseUserCmdPB::has_cmd_flags() const {
  return _internal_has_cmd_flags();
}
inline void CBaseUserCmdPB::clear_cmd_flags() {
  _impl_.cmd_flags_ = 0;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline int32_t CBaseUserCmdPB::_internal_cmd_flags() const {
  return _impl_.cmd_flags_;
}
inline int32_t CBaseUserCmdPB::cmd_flags() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.cmd_flags)
  return _internal_cmd_flags();
}
inline void CBaseUserCmdPB::_internal_set_cmd_flags(int32_t value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.cmd_flags_ = value;
}
inline void CBaseUserCmdPB::set_cmd_flags(int32_t value) {
  _internal_set_cmd_flags(value);
  // @@protoc_insertion_point(field_set:CBaseUserCmdPB.cmd_flags)
}

// optional .CBaseUserCmdExecutionNotes execution_notes = 22;
inline bool CBaseUserCmdPB::_internal_has_execution_notes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.execution_notes_ != nullptr);
  return value;
}
inline bool CBaseUserCmdPB::has_execution_notes() const {
  return _internal_has_execution_notes();
}
inline void CBaseUserCmdPB::clear_execution_notes() {
  if (_impl_.execution_notes_ != nullptr) _impl_.execution_notes_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::CBaseUserCmdExecutionNotes& CBaseUserCmdPB::_internal_execution_notes() const {
  const ::CBaseUserCmdExecutionNotes* p = _impl_.execution_notes_;
  return p != nullptr ? *p : reinterpret_cast<const ::CBaseUserCmdExecutionNotes&>(
      ::_CBaseUserCmdExecutionNotes_default_instance_);
}
inline const ::CBaseUserCmdExecutionNotes& CBaseUserCmdPB::execution_notes() const {
  // @@protoc_insertion_point(field_get:CBaseUserCmdPB.execution_notes)
  return _internal_execution_notes();
}
inline void CBaseUserCmdPB::unsafe_arena_set_allocated_execution_notes(
    ::CBaseUserCmdExecutionNotes* execution_notes) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.execution_notes_);
  }
  _impl_.execution_notes_ = execution_notes;
  if (execution_notes) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CBaseUserCmdPB.execution_notes)
}
inline ::CBaseUserCmdExecutionNotes* CBaseUserCmdPB::release_execution_notes() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CBaseUserCmdExecutionNotes* temp = _impl_.execution_notes_;
  _impl_.execution_notes_ = 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 ::CBaseUserCmdExecutionNotes* CBaseUserCmdPB::unsafe_arena_release_execution_notes() {
  // @@protoc_insertion_point(field_release:CBaseUserCmdPB.execution_notes)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CBaseUserCmdExecutionNotes* temp = _impl_.execution_notes_;
  _impl_.execution_notes_ = nullptr;
  return temp;
}
inline ::CBaseUserCmdExecutionNotes* CBaseUserCmdPB::_internal_mutable_execution_notes() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.execution_notes_ == nullptr) {
    auto* p = CreateMaybeMessage<::CBaseUserCmdExecutionNotes>(GetArenaForAllocation());
    _impl_.execution_notes_ = p;
  }
  return _impl_.execution_notes_;
}
inline ::CBaseUserCmdExecutionNotes* CBaseUserCmdPB::mutable_execution_notes() {
  ::CBaseUserCmdExecutionNotes* _msg = _internal_mutable_execution_notes();
  // @@protoc_insertion_point(field_mutable:CBaseUserCmdPB.execution_notes)
  return _msg;
}
inline void CBaseUserCmdPB::set_allocated_execution_notes(::CBaseUserCmdExecutionNotes* execution_notes) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.execution_notes_;
  }
  if (execution_notes) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(execution_notes);
    if (message_arena != submessage_arena) {
      execution_notes = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, execution_notes, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.execution_notes_ = execution_notes;
  // @@protoc_insertion_point(field_set_allocated:CBaseUserCmdPB.execution_notes)
}

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

// CUserCmdBasePB

// optional .CBaseUserCmdPB base = 1;
inline bool CUserCmdBasePB::_internal_has_base() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.base_ != nullptr);
  return value;
}
inline bool CUserCmdBasePB::has_base() const {
  return _internal_has_base();
}
inline void CUserCmdBasePB::clear_base() {
  if (_impl_.base_ != nullptr) _impl_.base_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CBaseUserCmdPB& CUserCmdBasePB::_internal_base() const {
  const ::CBaseUserCmdPB* p = _impl_.base_;
  return p != nullptr ? *p : reinterpret_cast<const ::CBaseUserCmdPB&>(
      ::_CBaseUserCmdPB_default_instance_);
}
inline const ::CBaseUserCmdPB& CUserCmdBasePB::base() const {
  // @@protoc_insertion_point(field_get:CUserCmdBasePB.base)
  return _internal_base();
}
inline void CUserCmdBasePB::unsafe_arena_set_allocated_base(
    ::CBaseUserCmdPB* 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:CUserCmdBasePB.base)
}
inline ::CBaseUserCmdPB* CUserCmdBasePB::release_base() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CBaseUserCmdPB* 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 ::CBaseUserCmdPB* CUserCmdBasePB::unsafe_arena_release_base() {
  // @@protoc_insertion_point(field_release:CUserCmdBasePB.base)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CBaseUserCmdPB* temp = _impl_.base_;
  _impl_.base_ = nullptr;
  return temp;
}
inline ::CBaseUserCmdPB* CUserCmdBasePB::_internal_mutable_base() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.base_ == nullptr) {
    auto* p = CreateMaybeMessage<::CBaseUserCmdPB>(GetArenaForAllocation());
    _impl_.base_ = p;
  }
  return _impl_.base_;
}
inline ::CBaseUserCmdPB* CUserCmdBasePB::mutable_base() {
  ::CBaseUserCmdPB* _msg = _internal_mutable_base();
  // @@protoc_insertion_point(field_mutable:CUserCmdBasePB.base)
  return _msg;
}
inline void CUserCmdBasePB::set_allocated_base(::CBaseUserCmdPB* 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:CUserCmdBasePB.base)
}

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


// @@protoc_insertion_point(global_scope)

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