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

#ifndef GOOGLE_PROTOBUF_INCLUDED_message_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_message_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3013000
#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 3013000 < 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_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.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>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_message_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_message_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[8]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_message_2eproto;
namespace NavMessage {
class AGVStatu;
class AGVStatuDefaultTypeInternal;
extern AGVStatuDefaultTypeInternal _AGVStatu_default_instance_;
class Action;
class ActionDefaultTypeInternal;
extern ActionDefaultTypeInternal _Action_default_instance_;
class NavCmd;
class NavCmdDefaultTypeInternal;
extern NavCmdDefaultTypeInternal _NavCmd_default_instance_;
class NavStatu;
class NavStatuDefaultTypeInternal;
extern NavStatuDefaultTypeInternal _NavStatu_default_instance_;
class Pose2d;
class Pose2dDefaultTypeInternal;
extern Pose2dDefaultTypeInternal _Pose2d_default_instance_;
class Speed;
class SpeedDefaultTypeInternal;
extern SpeedDefaultTypeInternal _Speed_default_instance_;
class SpeedLimit;
class SpeedLimitDefaultTypeInternal;
extern SpeedLimitDefaultTypeInternal _SpeedLimit_default_instance_;
class Trajectory;
class TrajectoryDefaultTypeInternal;
extern TrajectoryDefaultTypeInternal _Trajectory_default_instance_;
}  // namespace NavMessage
PROTOBUF_NAMESPACE_OPEN
template<> ::NavMessage::AGVStatu* Arena::CreateMaybeMessage<::NavMessage::AGVStatu>(Arena*);
template<> ::NavMessage::Action* Arena::CreateMaybeMessage<::NavMessage::Action>(Arena*);
template<> ::NavMessage::NavCmd* Arena::CreateMaybeMessage<::NavMessage::NavCmd>(Arena*);
template<> ::NavMessage::NavStatu* Arena::CreateMaybeMessage<::NavMessage::NavStatu>(Arena*);
template<> ::NavMessage::Pose2d* Arena::CreateMaybeMessage<::NavMessage::Pose2d>(Arena*);
template<> ::NavMessage::Speed* Arena::CreateMaybeMessage<::NavMessage::Speed>(Arena*);
template<> ::NavMessage::SpeedLimit* Arena::CreateMaybeMessage<::NavMessage::SpeedLimit>(Arena*);
template<> ::NavMessage::Trajectory* Arena::CreateMaybeMessage<::NavMessage::Trajectory>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace NavMessage {

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

class AGVStatu PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.AGVStatu) */ {
 public:
  inline AGVStatu() : AGVStatu(nullptr) {}
  virtual ~AGVStatu();

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

  inline AGVStatu& operator=(const AGVStatu& from) {
    CopyFrom(from);
    return *this;
  }
  inline AGVStatu& operator=(AGVStatu&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const AGVStatu& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const AGVStatu* internal_default_instance() {
    return reinterpret_cast<const AGVStatu*>(
               &_AGVStatu_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(AGVStatu& a, AGVStatu& b) {
    a.Swap(&b);
  }
  inline void Swap(AGVStatu* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AGVStatu* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline AGVStatu* New() const final {
    return CreateMaybeMessage<AGVStatu>(nullptr);
  }

  AGVStatu* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AGVStatu>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const AGVStatu& from);
  void MergeFrom(const AGVStatu& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AGVStatu* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.AGVStatu";
  }
  protected:
  explicit AGVStatu(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kXFieldNumber = 1,
    kYFieldNumber = 2,
    kThetaFieldNumber = 3,
    kVFieldNumber = 4,
    kVthFieldNumber = 5,
  };
  // float x = 1;
  void clear_x();
  float x() const;
  void set_x(float value);
  private:
  float _internal_x() const;
  void _internal_set_x(float value);
  public:

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

  // float theta = 3;
  void clear_theta();
  float theta() const;
  void set_theta(float value);
  private:
  float _internal_theta() const;
  void _internal_set_theta(float value);
  public:

  // float v = 4;
  void clear_v();
  float v() const;
  void set_v(float value);
  private:
  float _internal_v() const;
  void _internal_set_v(float value);
  public:

  // float vth = 5;
  void clear_vth();
  float vth() const;
  void set_vth(float value);
  private:
  float _internal_vth() const;
  void _internal_set_vth(float value);
  public:

  // @@protoc_insertion_point(class_scope:NavMessage.AGVStatu)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  float x_;
  float y_;
  float theta_;
  float v_;
  float vth_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class Speed PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.Speed) */ {
 public:
  inline Speed() : Speed(nullptr) {}
  virtual ~Speed();

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

  inline Speed& operator=(const Speed& from) {
    CopyFrom(from);
    return *this;
  }
  inline Speed& operator=(Speed&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Speed& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Speed* internal_default_instance() {
    return reinterpret_cast<const Speed*>(
               &_Speed_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Speed& a, Speed& b) {
    a.Swap(&b);
  }
  inline void Swap(Speed* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Speed* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Speed* New() const final {
    return CreateMaybeMessage<Speed>(nullptr);
  }

  Speed* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Speed>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Speed& from);
  void MergeFrom(const Speed& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Speed* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.Speed";
  }
  protected:
  explicit Speed(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kHFieldNumber = 1,
    kTFieldNumber = 2,
    kVFieldNumber = 3,
    kWFieldNumber = 4,
    kEndFieldNumber = 5,
  };
  // int32 H = 1;
  void clear_h();
  ::PROTOBUF_NAMESPACE_ID::int32 h() const;
  void set_h(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_h() const;
  void _internal_set_h(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 T = 2;
  void clear_t();
  ::PROTOBUF_NAMESPACE_ID::int32 t() const;
  void set_t(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_t() const;
  void _internal_set_t(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // float V = 3;
  void clear_v();
  float v() const;
  void set_v(float value);
  private:
  float _internal_v() const;
  void _internal_set_v(float value);
  public:

  // float W = 4;
  void clear_w();
  float w() const;
  void set_w(float value);
  private:
  float _internal_w() const;
  void _internal_set_w(float value);
  public:

  // int32 end = 5;
  void clear_end();
  ::PROTOBUF_NAMESPACE_ID::int32 end() const;
  void set_end(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_end() const;
  void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:NavMessage.Speed)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int32 h_;
  ::PROTOBUF_NAMESPACE_ID::int32 t_;
  float v_;
  float w_;
  ::PROTOBUF_NAMESPACE_ID::int32 end_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class SpeedLimit PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.SpeedLimit) */ {
 public:
  inline SpeedLimit() : SpeedLimit(nullptr) {}
  virtual ~SpeedLimit();

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

  inline SpeedLimit& operator=(const SpeedLimit& from) {
    CopyFrom(from);
    return *this;
  }
  inline SpeedLimit& operator=(SpeedLimit&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SpeedLimit& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SpeedLimit* internal_default_instance() {
    return reinterpret_cast<const SpeedLimit*>(
               &_SpeedLimit_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(SpeedLimit& a, SpeedLimit& b) {
    a.Swap(&b);
  }
  inline void Swap(SpeedLimit* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SpeedLimit* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SpeedLimit* New() const final {
    return CreateMaybeMessage<SpeedLimit>(nullptr);
  }

  SpeedLimit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SpeedLimit>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SpeedLimit& from);
  void MergeFrom(const SpeedLimit& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SpeedLimit* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.SpeedLimit";
  }
  protected:
  explicit SpeedLimit(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kMinFieldNumber = 1,
    kMaxFieldNumber = 2,
  };
  // float min = 1;
  void clear_min();
  float min() const;
  void set_min(float value);
  private:
  float _internal_min() const;
  void _internal_set_min(float value);
  public:

  // float max = 2;
  void clear_max();
  float max() const;
  void set_max(float value);
  private:
  float _internal_max() const;
  void _internal_set_max(float value);
  public:

  // @@protoc_insertion_point(class_scope:NavMessage.SpeedLimit)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  float min_;
  float max_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class Pose2d PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.Pose2d) */ {
 public:
  inline Pose2d() : Pose2d(nullptr) {}
  virtual ~Pose2d();

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

  inline Pose2d& operator=(const Pose2d& from) {
    CopyFrom(from);
    return *this;
  }
  inline Pose2d& operator=(Pose2d&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Pose2d& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Pose2d* internal_default_instance() {
    return reinterpret_cast<const Pose2d*>(
               &_Pose2d_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(Pose2d& a, Pose2d& b) {
    a.Swap(&b);
  }
  inline void Swap(Pose2d* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Pose2d* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Pose2d* New() const final {
    return CreateMaybeMessage<Pose2d>(nullptr);
  }

  Pose2d* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Pose2d>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Pose2d& from);
  void MergeFrom(const Pose2d& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Pose2d* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.Pose2d";
  }
  protected:
  explicit Pose2d(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

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

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

  // float theta = 3;
  void clear_theta();
  float theta() const;
  void set_theta(float value);
  private:
  float _internal_theta() const;
  void _internal_set_theta(float value);
  public:

  // @@protoc_insertion_point(class_scope:NavMessage.Pose2d)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  float x_;
  float y_;
  float theta_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class Trajectory PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.Trajectory) */ {
 public:
  inline Trajectory() : Trajectory(nullptr) {}
  virtual ~Trajectory();

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

  inline Trajectory& operator=(const Trajectory& from) {
    CopyFrom(from);
    return *this;
  }
  inline Trajectory& operator=(Trajectory&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Trajectory& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Trajectory* internal_default_instance() {
    return reinterpret_cast<const Trajectory*>(
               &_Trajectory_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(Trajectory& a, Trajectory& b) {
    a.Swap(&b);
  }
  inline void Swap(Trajectory* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Trajectory* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Trajectory* New() const final {
    return CreateMaybeMessage<Trajectory>(nullptr);
  }

  Trajectory* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Trajectory>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Trajectory& from);
  void MergeFrom(const Trajectory& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Trajectory* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.Trajectory";
  }
  protected:
  explicit Trajectory(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPosesFieldNumber = 1,
  };
  // repeated .NavMessage.Pose2d poses = 1;
  int poses_size() const;
  private:
  int _internal_poses_size() const;
  public:
  void clear_poses();
  ::NavMessage::Pose2d* mutable_poses(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Pose2d >*
      mutable_poses();
  private:
  const ::NavMessage::Pose2d& _internal_poses(int index) const;
  ::NavMessage::Pose2d* _internal_add_poses();
  public:
  const ::NavMessage::Pose2d& poses(int index) const;
  ::NavMessage::Pose2d* add_poses();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Pose2d >&
      poses() const;

  // @@protoc_insertion_point(class_scope:NavMessage.Trajectory)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Pose2d > poses_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class Action PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.Action) */ {
 public:
  inline Action() : Action(nullptr) {}
  virtual ~Action();

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

  inline Action& operator=(const Action& from) {
    CopyFrom(from);
    return *this;
  }
  inline Action& operator=(Action&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Action& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Action* internal_default_instance() {
    return reinterpret_cast<const Action*>(
               &_Action_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(Action& a, Action& b) {
    a.Swap(&b);
  }
  inline void Swap(Action* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Action* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Action* New() const final {
    return CreateMaybeMessage<Action>(nullptr);
  }

  Action* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Action>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Action& from);
  void MergeFrom(const Action& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Action* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.Action";
  }
  protected:
  explicit Action(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kBeginFieldNumber = 2,
    kTargetFieldNumber = 3,
    kTargetDiffFieldNumber = 4,
    kVelocityLimitFieldNumber = 5,
    kAngularLimitFieldNumber = 6,
    kHorizeLimitFieldNumber = 7,
    kTypeFieldNumber = 1,
  };
  // .NavMessage.Pose2d begin = 2;
  bool has_begin() const;
  private:
  bool _internal_has_begin() const;
  public:
  void clear_begin();
  const ::NavMessage::Pose2d& begin() const;
  ::NavMessage::Pose2d* release_begin();
  ::NavMessage::Pose2d* mutable_begin();
  void set_allocated_begin(::NavMessage::Pose2d* begin);
  private:
  const ::NavMessage::Pose2d& _internal_begin() const;
  ::NavMessage::Pose2d* _internal_mutable_begin();
  public:
  void unsafe_arena_set_allocated_begin(
      ::NavMessage::Pose2d* begin);
  ::NavMessage::Pose2d* unsafe_arena_release_begin();

  // .NavMessage.Pose2d target = 3;
  bool has_target() const;
  private:
  bool _internal_has_target() const;
  public:
  void clear_target();
  const ::NavMessage::Pose2d& target() const;
  ::NavMessage::Pose2d* release_target();
  ::NavMessage::Pose2d* mutable_target();
  void set_allocated_target(::NavMessage::Pose2d* target);
  private:
  const ::NavMessage::Pose2d& _internal_target() const;
  ::NavMessage::Pose2d* _internal_mutable_target();
  public:
  void unsafe_arena_set_allocated_target(
      ::NavMessage::Pose2d* target);
  ::NavMessage::Pose2d* unsafe_arena_release_target();

  // .NavMessage.Pose2d target_diff = 4;
  bool has_target_diff() const;
  private:
  bool _internal_has_target_diff() const;
  public:
  void clear_target_diff();
  const ::NavMessage::Pose2d& target_diff() const;
  ::NavMessage::Pose2d* release_target_diff();
  ::NavMessage::Pose2d* mutable_target_diff();
  void set_allocated_target_diff(::NavMessage::Pose2d* target_diff);
  private:
  const ::NavMessage::Pose2d& _internal_target_diff() const;
  ::NavMessage::Pose2d* _internal_mutable_target_diff();
  public:
  void unsafe_arena_set_allocated_target_diff(
      ::NavMessage::Pose2d* target_diff);
  ::NavMessage::Pose2d* unsafe_arena_release_target_diff();

  // .NavMessage.SpeedLimit velocity_limit = 5;
  bool has_velocity_limit() const;
  private:
  bool _internal_has_velocity_limit() const;
  public:
  void clear_velocity_limit();
  const ::NavMessage::SpeedLimit& velocity_limit() const;
  ::NavMessage::SpeedLimit* release_velocity_limit();
  ::NavMessage::SpeedLimit* mutable_velocity_limit();
  void set_allocated_velocity_limit(::NavMessage::SpeedLimit* velocity_limit);
  private:
  const ::NavMessage::SpeedLimit& _internal_velocity_limit() const;
  ::NavMessage::SpeedLimit* _internal_mutable_velocity_limit();
  public:
  void unsafe_arena_set_allocated_velocity_limit(
      ::NavMessage::SpeedLimit* velocity_limit);
  ::NavMessage::SpeedLimit* unsafe_arena_release_velocity_limit();

  // .NavMessage.SpeedLimit angular_limit = 6;
  bool has_angular_limit() const;
  private:
  bool _internal_has_angular_limit() const;
  public:
  void clear_angular_limit();
  const ::NavMessage::SpeedLimit& angular_limit() const;
  ::NavMessage::SpeedLimit* release_angular_limit();
  ::NavMessage::SpeedLimit* mutable_angular_limit();
  void set_allocated_angular_limit(::NavMessage::SpeedLimit* angular_limit);
  private:
  const ::NavMessage::SpeedLimit& _internal_angular_limit() const;
  ::NavMessage::SpeedLimit* _internal_mutable_angular_limit();
  public:
  void unsafe_arena_set_allocated_angular_limit(
      ::NavMessage::SpeedLimit* angular_limit);
  ::NavMessage::SpeedLimit* unsafe_arena_release_angular_limit();

  // .NavMessage.SpeedLimit horize_limit = 7;
  bool has_horize_limit() const;
  private:
  bool _internal_has_horize_limit() const;
  public:
  void clear_horize_limit();
  const ::NavMessage::SpeedLimit& horize_limit() const;
  ::NavMessage::SpeedLimit* release_horize_limit();
  ::NavMessage::SpeedLimit* mutable_horize_limit();
  void set_allocated_horize_limit(::NavMessage::SpeedLimit* horize_limit);
  private:
  const ::NavMessage::SpeedLimit& _internal_horize_limit() const;
  ::NavMessage::SpeedLimit* _internal_mutable_horize_limit();
  public:
  void unsafe_arena_set_allocated_horize_limit(
      ::NavMessage::SpeedLimit* horize_limit);
  ::NavMessage::SpeedLimit* unsafe_arena_release_horize_limit();

  // int32 type = 1;
  void clear_type();
  ::PROTOBUF_NAMESPACE_ID::int32 type() const;
  void set_type(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_type() const;
  void _internal_set_type(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:NavMessage.Action)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::NavMessage::Pose2d* begin_;
  ::NavMessage::Pose2d* target_;
  ::NavMessage::Pose2d* target_diff_;
  ::NavMessage::SpeedLimit* velocity_limit_;
  ::NavMessage::SpeedLimit* angular_limit_;
  ::NavMessage::SpeedLimit* horize_limit_;
  ::PROTOBUF_NAMESPACE_ID::int32 type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class NavCmd PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.NavCmd) */ {
 public:
  inline NavCmd() : NavCmd(nullptr) {}
  virtual ~NavCmd();

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

  inline NavCmd& operator=(const NavCmd& from) {
    CopyFrom(from);
    return *this;
  }
  inline NavCmd& operator=(NavCmd&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const NavCmd& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const NavCmd* internal_default_instance() {
    return reinterpret_cast<const NavCmd*>(
               &_NavCmd_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(NavCmd& a, NavCmd& b) {
    a.Swap(&b);
  }
  inline void Swap(NavCmd* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NavCmd* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline NavCmd* New() const final {
    return CreateMaybeMessage<NavCmd>(nullptr);
  }

  NavCmd* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<NavCmd>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const NavCmd& from);
  void MergeFrom(const NavCmd& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NavCmd* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.NavCmd";
  }
  protected:
  explicit NavCmd(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kActionsFieldNumber = 3,
    kKeyFieldNumber = 2,
    kActionFieldNumber = 1,
  };
  // repeated .NavMessage.Action actions = 3;
  int actions_size() const;
  private:
  int _internal_actions_size() const;
  public:
  void clear_actions();
  ::NavMessage::Action* mutable_actions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Action >*
      mutable_actions();
  private:
  const ::NavMessage::Action& _internal_actions(int index) const;
  ::NavMessage::Action* _internal_add_actions();
  public:
  const ::NavMessage::Action& actions(int index) const;
  ::NavMessage::Action* add_actions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Action >&
      actions() const;

  // string key = 2;
  void clear_key();
  const std::string& key() const;
  void set_key(const std::string& value);
  void set_key(std::string&& value);
  void set_key(const char* value);
  void set_key(const char* value, size_t size);
  std::string* mutable_key();
  std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // int32 action = 1;
  void clear_action();
  ::PROTOBUF_NAMESPACE_ID::int32 action() const;
  void set_action(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_action() const;
  void _internal_set_action(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:NavMessage.NavCmd)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Action > actions_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
  ::PROTOBUF_NAMESPACE_ID::int32 action_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// -------------------------------------------------------------------

class NavStatu PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:NavMessage.NavStatu) */ {
 public:
  inline NavStatu() : NavStatu(nullptr) {}
  virtual ~NavStatu();

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

  inline NavStatu& operator=(const NavStatu& from) {
    CopyFrom(from);
    return *this;
  }
  inline NavStatu& operator=(NavStatu&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const NavStatu& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const NavStatu* internal_default_instance() {
    return reinterpret_cast<const NavStatu*>(
               &_NavStatu_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(NavStatu& a, NavStatu& b) {
    a.Swap(&b);
  }
  inline void Swap(NavStatu* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NavStatu* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline NavStatu* New() const final {
    return CreateMaybeMessage<NavStatu>(nullptr);
  }

  NavStatu* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<NavStatu>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const NavStatu& from);
  void MergeFrom(const NavStatu& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NavStatu* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "NavMessage.NavStatu";
  }
  protected:
  explicit NavStatu(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_message_2eproto);
    return ::descriptor_table_message_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kUnfinishedActionsFieldNumber = 3,
    kKeyFieldNumber = 2,
    kSelectedTrajFieldNumber = 4,
    kPredictTrajFieldNumber = 5,
    kStatuFieldNumber = 1,
  };
  // repeated .NavMessage.Action unfinished_actions = 3;
  int unfinished_actions_size() const;
  private:
  int _internal_unfinished_actions_size() const;
  public:
  void clear_unfinished_actions();
  ::NavMessage::Action* mutable_unfinished_actions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Action >*
      mutable_unfinished_actions();
  private:
  const ::NavMessage::Action& _internal_unfinished_actions(int index) const;
  ::NavMessage::Action* _internal_add_unfinished_actions();
  public:
  const ::NavMessage::Action& unfinished_actions(int index) const;
  ::NavMessage::Action* add_unfinished_actions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Action >&
      unfinished_actions() const;

  // string key = 2;
  void clear_key();
  const std::string& key() const;
  void set_key(const std::string& value);
  void set_key(std::string&& value);
  void set_key(const char* value);
  void set_key(const char* value, size_t size);
  std::string* mutable_key();
  std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // .NavMessage.Trajectory selected_traj = 4;
  bool has_selected_traj() const;
  private:
  bool _internal_has_selected_traj() const;
  public:
  void clear_selected_traj();
  const ::NavMessage::Trajectory& selected_traj() const;
  ::NavMessage::Trajectory* release_selected_traj();
  ::NavMessage::Trajectory* mutable_selected_traj();
  void set_allocated_selected_traj(::NavMessage::Trajectory* selected_traj);
  private:
  const ::NavMessage::Trajectory& _internal_selected_traj() const;
  ::NavMessage::Trajectory* _internal_mutable_selected_traj();
  public:
  void unsafe_arena_set_allocated_selected_traj(
      ::NavMessage::Trajectory* selected_traj);
  ::NavMessage::Trajectory* unsafe_arena_release_selected_traj();

  // .NavMessage.Trajectory predict_traj = 5;
  bool has_predict_traj() const;
  private:
  bool _internal_has_predict_traj() const;
  public:
  void clear_predict_traj();
  const ::NavMessage::Trajectory& predict_traj() const;
  ::NavMessage::Trajectory* release_predict_traj();
  ::NavMessage::Trajectory* mutable_predict_traj();
  void set_allocated_predict_traj(::NavMessage::Trajectory* predict_traj);
  private:
  const ::NavMessage::Trajectory& _internal_predict_traj() const;
  ::NavMessage::Trajectory* _internal_mutable_predict_traj();
  public:
  void unsafe_arena_set_allocated_predict_traj(
      ::NavMessage::Trajectory* predict_traj);
  ::NavMessage::Trajectory* unsafe_arena_release_predict_traj();

  // bool statu = 1;
  void clear_statu();
  bool statu() const;
  void set_statu(bool value);
  private:
  bool _internal_statu() const;
  void _internal_set_statu(bool value);
  public:

  // @@protoc_insertion_point(class_scope:NavMessage.NavStatu)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Action > unfinished_actions_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
  ::NavMessage::Trajectory* selected_traj_;
  ::NavMessage::Trajectory* predict_traj_;
  bool statu_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_message_2eproto;
};
// ===================================================================


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

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

// float x = 1;
inline void AGVStatu::clear_x() {
  x_ = 0;
}
inline float AGVStatu::_internal_x() const {
  return x_;
}
inline float AGVStatu::x() const {
  // @@protoc_insertion_point(field_get:NavMessage.AGVStatu.x)
  return _internal_x();
}
inline void AGVStatu::_internal_set_x(float value) {
  
  x_ = value;
}
inline void AGVStatu::set_x(float value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:NavMessage.AGVStatu.x)
}

// float y = 2;
inline void AGVStatu::clear_y() {
  y_ = 0;
}
inline float AGVStatu::_internal_y() const {
  return y_;
}
inline float AGVStatu::y() const {
  // @@protoc_insertion_point(field_get:NavMessage.AGVStatu.y)
  return _internal_y();
}
inline void AGVStatu::_internal_set_y(float value) {
  
  y_ = value;
}
inline void AGVStatu::set_y(float value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:NavMessage.AGVStatu.y)
}

// float theta = 3;
inline void AGVStatu::clear_theta() {
  theta_ = 0;
}
inline float AGVStatu::_internal_theta() const {
  return theta_;
}
inline float AGVStatu::theta() const {
  // @@protoc_insertion_point(field_get:NavMessage.AGVStatu.theta)
  return _internal_theta();
}
inline void AGVStatu::_internal_set_theta(float value) {
  
  theta_ = value;
}
inline void AGVStatu::set_theta(float value) {
  _internal_set_theta(value);
  // @@protoc_insertion_point(field_set:NavMessage.AGVStatu.theta)
}

// float v = 4;
inline void AGVStatu::clear_v() {
  v_ = 0;
}
inline float AGVStatu::_internal_v() const {
  return v_;
}
inline float AGVStatu::v() const {
  // @@protoc_insertion_point(field_get:NavMessage.AGVStatu.v)
  return _internal_v();
}
inline void AGVStatu::_internal_set_v(float value) {
  
  v_ = value;
}
inline void AGVStatu::set_v(float value) {
  _internal_set_v(value);
  // @@protoc_insertion_point(field_set:NavMessage.AGVStatu.v)
}

// float vth = 5;
inline void AGVStatu::clear_vth() {
  vth_ = 0;
}
inline float AGVStatu::_internal_vth() const {
  return vth_;
}
inline float AGVStatu::vth() const {
  // @@protoc_insertion_point(field_get:NavMessage.AGVStatu.vth)
  return _internal_vth();
}
inline void AGVStatu::_internal_set_vth(float value) {
  
  vth_ = value;
}
inline void AGVStatu::set_vth(float value) {
  _internal_set_vth(value);
  // @@protoc_insertion_point(field_set:NavMessage.AGVStatu.vth)
}

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

// Speed

// int32 H = 1;
inline void Speed::clear_h() {
  h_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Speed::_internal_h() const {
  return h_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Speed::h() const {
  // @@protoc_insertion_point(field_get:NavMessage.Speed.H)
  return _internal_h();
}
inline void Speed::_internal_set_h(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  h_ = value;
}
inline void Speed::set_h(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_h(value);
  // @@protoc_insertion_point(field_set:NavMessage.Speed.H)
}

// int32 T = 2;
inline void Speed::clear_t() {
  t_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Speed::_internal_t() const {
  return t_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Speed::t() const {
  // @@protoc_insertion_point(field_get:NavMessage.Speed.T)
  return _internal_t();
}
inline void Speed::_internal_set_t(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  t_ = value;
}
inline void Speed::set_t(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_t(value);
  // @@protoc_insertion_point(field_set:NavMessage.Speed.T)
}

// float V = 3;
inline void Speed::clear_v() {
  v_ = 0;
}
inline float Speed::_internal_v() const {
  return v_;
}
inline float Speed::v() const {
  // @@protoc_insertion_point(field_get:NavMessage.Speed.V)
  return _internal_v();
}
inline void Speed::_internal_set_v(float value) {
  
  v_ = value;
}
inline void Speed::set_v(float value) {
  _internal_set_v(value);
  // @@protoc_insertion_point(field_set:NavMessage.Speed.V)
}

// float W = 4;
inline void Speed::clear_w() {
  w_ = 0;
}
inline float Speed::_internal_w() const {
  return w_;
}
inline float Speed::w() const {
  // @@protoc_insertion_point(field_get:NavMessage.Speed.W)
  return _internal_w();
}
inline void Speed::_internal_set_w(float value) {
  
  w_ = value;
}
inline void Speed::set_w(float value) {
  _internal_set_w(value);
  // @@protoc_insertion_point(field_set:NavMessage.Speed.W)
}

// int32 end = 5;
inline void Speed::clear_end() {
  end_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Speed::_internal_end() const {
  return end_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Speed::end() const {
  // @@protoc_insertion_point(field_get:NavMessage.Speed.end)
  return _internal_end();
}
inline void Speed::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  end_ = value;
}
inline void Speed::set_end(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_end(value);
  // @@protoc_insertion_point(field_set:NavMessage.Speed.end)
}

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

// SpeedLimit

// float min = 1;
inline void SpeedLimit::clear_min() {
  min_ = 0;
}
inline float SpeedLimit::_internal_min() const {
  return min_;
}
inline float SpeedLimit::min() const {
  // @@protoc_insertion_point(field_get:NavMessage.SpeedLimit.min)
  return _internal_min();
}
inline void SpeedLimit::_internal_set_min(float value) {
  
  min_ = value;
}
inline void SpeedLimit::set_min(float value) {
  _internal_set_min(value);
  // @@protoc_insertion_point(field_set:NavMessage.SpeedLimit.min)
}

// float max = 2;
inline void SpeedLimit::clear_max() {
  max_ = 0;
}
inline float SpeedLimit::_internal_max() const {
  return max_;
}
inline float SpeedLimit::max() const {
  // @@protoc_insertion_point(field_get:NavMessage.SpeedLimit.max)
  return _internal_max();
}
inline void SpeedLimit::_internal_set_max(float value) {
  
  max_ = value;
}
inline void SpeedLimit::set_max(float value) {
  _internal_set_max(value);
  // @@protoc_insertion_point(field_set:NavMessage.SpeedLimit.max)
}

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

// Pose2d

// float x = 1;
inline void Pose2d::clear_x() {
  x_ = 0;
}
inline float Pose2d::_internal_x() const {
  return x_;
}
inline float Pose2d::x() const {
  // @@protoc_insertion_point(field_get:NavMessage.Pose2d.x)
  return _internal_x();
}
inline void Pose2d::_internal_set_x(float value) {
  
  x_ = value;
}
inline void Pose2d::set_x(float value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:NavMessage.Pose2d.x)
}

// float y = 2;
inline void Pose2d::clear_y() {
  y_ = 0;
}
inline float Pose2d::_internal_y() const {
  return y_;
}
inline float Pose2d::y() const {
  // @@protoc_insertion_point(field_get:NavMessage.Pose2d.y)
  return _internal_y();
}
inline void Pose2d::_internal_set_y(float value) {
  
  y_ = value;
}
inline void Pose2d::set_y(float value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:NavMessage.Pose2d.y)
}

// float theta = 3;
inline void Pose2d::clear_theta() {
  theta_ = 0;
}
inline float Pose2d::_internal_theta() const {
  return theta_;
}
inline float Pose2d::theta() const {
  // @@protoc_insertion_point(field_get:NavMessage.Pose2d.theta)
  return _internal_theta();
}
inline void Pose2d::_internal_set_theta(float value) {
  
  theta_ = value;
}
inline void Pose2d::set_theta(float value) {
  _internal_set_theta(value);
  // @@protoc_insertion_point(field_set:NavMessage.Pose2d.theta)
}

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

// Trajectory

// repeated .NavMessage.Pose2d poses = 1;
inline int Trajectory::_internal_poses_size() const {
  return poses_.size();
}
inline int Trajectory::poses_size() const {
  return _internal_poses_size();
}
inline void Trajectory::clear_poses() {
  poses_.Clear();
}
inline ::NavMessage::Pose2d* Trajectory::mutable_poses(int index) {
  // @@protoc_insertion_point(field_mutable:NavMessage.Trajectory.poses)
  return poses_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Pose2d >*
Trajectory::mutable_poses() {
  // @@protoc_insertion_point(field_mutable_list:NavMessage.Trajectory.poses)
  return &poses_;
}
inline const ::NavMessage::Pose2d& Trajectory::_internal_poses(int index) const {
  return poses_.Get(index);
}
inline const ::NavMessage::Pose2d& Trajectory::poses(int index) const {
  // @@protoc_insertion_point(field_get:NavMessage.Trajectory.poses)
  return _internal_poses(index);
}
inline ::NavMessage::Pose2d* Trajectory::_internal_add_poses() {
  return poses_.Add();
}
inline ::NavMessage::Pose2d* Trajectory::add_poses() {
  // @@protoc_insertion_point(field_add:NavMessage.Trajectory.poses)
  return _internal_add_poses();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Pose2d >&
Trajectory::poses() const {
  // @@protoc_insertion_point(field_list:NavMessage.Trajectory.poses)
  return poses_;
}

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

// Action

// int32 type = 1;
inline void Action::clear_type() {
  type_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Action::_internal_type() const {
  return type_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Action::type() const {
  // @@protoc_insertion_point(field_get:NavMessage.Action.type)
  return _internal_type();
}
inline void Action::_internal_set_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  type_ = value;
}
inline void Action::set_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:NavMessage.Action.type)
}

// .NavMessage.Pose2d begin = 2;
inline bool Action::_internal_has_begin() const {
  return this != internal_default_instance() && begin_ != nullptr;
}
inline bool Action::has_begin() const {
  return _internal_has_begin();
}
inline void Action::clear_begin() {
  if (GetArena() == nullptr && begin_ != nullptr) {
    delete begin_;
  }
  begin_ = nullptr;
}
inline const ::NavMessage::Pose2d& Action::_internal_begin() const {
  const ::NavMessage::Pose2d* p = begin_;
  return p != nullptr ? *p : *reinterpret_cast<const ::NavMessage::Pose2d*>(
      &::NavMessage::_Pose2d_default_instance_);
}
inline const ::NavMessage::Pose2d& Action::begin() const {
  // @@protoc_insertion_point(field_get:NavMessage.Action.begin)
  return _internal_begin();
}
inline void Action::unsafe_arena_set_allocated_begin(
    ::NavMessage::Pose2d* begin) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(begin_);
  }
  begin_ = begin;
  if (begin) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.Action.begin)
}
inline ::NavMessage::Pose2d* Action::release_begin() {
  
  ::NavMessage::Pose2d* temp = begin_;
  begin_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::Pose2d* Action::unsafe_arena_release_begin() {
  // @@protoc_insertion_point(field_release:NavMessage.Action.begin)
  
  ::NavMessage::Pose2d* temp = begin_;
  begin_ = nullptr;
  return temp;
}
inline ::NavMessage::Pose2d* Action::_internal_mutable_begin() {
  
  if (begin_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::Pose2d>(GetArena());
    begin_ = p;
  }
  return begin_;
}
inline ::NavMessage::Pose2d* Action::mutable_begin() {
  // @@protoc_insertion_point(field_mutable:NavMessage.Action.begin)
  return _internal_mutable_begin();
}
inline void Action::set_allocated_begin(::NavMessage::Pose2d* begin) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete begin_;
  }
  if (begin) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(begin);
    if (message_arena != submessage_arena) {
      begin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, begin, submessage_arena);
    }
    
  } else {
    
  }
  begin_ = begin;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.Action.begin)
}

// .NavMessage.Pose2d target = 3;
inline bool Action::_internal_has_target() const {
  return this != internal_default_instance() && target_ != nullptr;
}
inline bool Action::has_target() const {
  return _internal_has_target();
}
inline void Action::clear_target() {
  if (GetArena() == nullptr && target_ != nullptr) {
    delete target_;
  }
  target_ = nullptr;
}
inline const ::NavMessage::Pose2d& Action::_internal_target() const {
  const ::NavMessage::Pose2d* p = target_;
  return p != nullptr ? *p : *reinterpret_cast<const ::NavMessage::Pose2d*>(
      &::NavMessage::_Pose2d_default_instance_);
}
inline const ::NavMessage::Pose2d& Action::target() const {
  // @@protoc_insertion_point(field_get:NavMessage.Action.target)
  return _internal_target();
}
inline void Action::unsafe_arena_set_allocated_target(
    ::NavMessage::Pose2d* target) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(target_);
  }
  target_ = target;
  if (target) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.Action.target)
}
inline ::NavMessage::Pose2d* Action::release_target() {
  
  ::NavMessage::Pose2d* temp = target_;
  target_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::Pose2d* Action::unsafe_arena_release_target() {
  // @@protoc_insertion_point(field_release:NavMessage.Action.target)
  
  ::NavMessage::Pose2d* temp = target_;
  target_ = nullptr;
  return temp;
}
inline ::NavMessage::Pose2d* Action::_internal_mutable_target() {
  
  if (target_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::Pose2d>(GetArena());
    target_ = p;
  }
  return target_;
}
inline ::NavMessage::Pose2d* Action::mutable_target() {
  // @@protoc_insertion_point(field_mutable:NavMessage.Action.target)
  return _internal_mutable_target();
}
inline void Action::set_allocated_target(::NavMessage::Pose2d* target) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete target_;
  }
  if (target) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(target);
    if (message_arena != submessage_arena) {
      target = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, target, submessage_arena);
    }
    
  } else {
    
  }
  target_ = target;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.Action.target)
}

// .NavMessage.Pose2d target_diff = 4;
inline bool Action::_internal_has_target_diff() const {
  return this != internal_default_instance() && target_diff_ != nullptr;
}
inline bool Action::has_target_diff() const {
  return _internal_has_target_diff();
}
inline void Action::clear_target_diff() {
  if (GetArena() == nullptr && target_diff_ != nullptr) {
    delete target_diff_;
  }
  target_diff_ = nullptr;
}
inline const ::NavMessage::Pose2d& Action::_internal_target_diff() const {
  const ::NavMessage::Pose2d* p = target_diff_;
  return p != nullptr ? *p : *reinterpret_cast<const ::NavMessage::Pose2d*>(
      &::NavMessage::_Pose2d_default_instance_);
}
inline const ::NavMessage::Pose2d& Action::target_diff() const {
  // @@protoc_insertion_point(field_get:NavMessage.Action.target_diff)
  return _internal_target_diff();
}
inline void Action::unsafe_arena_set_allocated_target_diff(
    ::NavMessage::Pose2d* target_diff) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(target_diff_);
  }
  target_diff_ = target_diff;
  if (target_diff) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.Action.target_diff)
}
inline ::NavMessage::Pose2d* Action::release_target_diff() {
  
  ::NavMessage::Pose2d* temp = target_diff_;
  target_diff_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::Pose2d* Action::unsafe_arena_release_target_diff() {
  // @@protoc_insertion_point(field_release:NavMessage.Action.target_diff)
  
  ::NavMessage::Pose2d* temp = target_diff_;
  target_diff_ = nullptr;
  return temp;
}
inline ::NavMessage::Pose2d* Action::_internal_mutable_target_diff() {
  
  if (target_diff_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::Pose2d>(GetArena());
    target_diff_ = p;
  }
  return target_diff_;
}
inline ::NavMessage::Pose2d* Action::mutable_target_diff() {
  // @@protoc_insertion_point(field_mutable:NavMessage.Action.target_diff)
  return _internal_mutable_target_diff();
}
inline void Action::set_allocated_target_diff(::NavMessage::Pose2d* target_diff) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete target_diff_;
  }
  if (target_diff) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(target_diff);
    if (message_arena != submessage_arena) {
      target_diff = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, target_diff, submessage_arena);
    }
    
  } else {
    
  }
  target_diff_ = target_diff;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.Action.target_diff)
}

// .NavMessage.SpeedLimit velocity_limit = 5;
inline bool Action::_internal_has_velocity_limit() const {
  return this != internal_default_instance() && velocity_limit_ != nullptr;
}
inline bool Action::has_velocity_limit() const {
  return _internal_has_velocity_limit();
}
inline void Action::clear_velocity_limit() {
  if (GetArena() == nullptr && velocity_limit_ != nullptr) {
    delete velocity_limit_;
  }
  velocity_limit_ = nullptr;
}
inline const ::NavMessage::SpeedLimit& Action::_internal_velocity_limit() const {
  const ::NavMessage::SpeedLimit* p = velocity_limit_;
  return p != nullptr ? *p : *reinterpret_cast<const ::NavMessage::SpeedLimit*>(
      &::NavMessage::_SpeedLimit_default_instance_);
}
inline const ::NavMessage::SpeedLimit& Action::velocity_limit() const {
  // @@protoc_insertion_point(field_get:NavMessage.Action.velocity_limit)
  return _internal_velocity_limit();
}
inline void Action::unsafe_arena_set_allocated_velocity_limit(
    ::NavMessage::SpeedLimit* velocity_limit) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(velocity_limit_);
  }
  velocity_limit_ = velocity_limit;
  if (velocity_limit) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.Action.velocity_limit)
}
inline ::NavMessage::SpeedLimit* Action::release_velocity_limit() {
  
  ::NavMessage::SpeedLimit* temp = velocity_limit_;
  velocity_limit_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::SpeedLimit* Action::unsafe_arena_release_velocity_limit() {
  // @@protoc_insertion_point(field_release:NavMessage.Action.velocity_limit)
  
  ::NavMessage::SpeedLimit* temp = velocity_limit_;
  velocity_limit_ = nullptr;
  return temp;
}
inline ::NavMessage::SpeedLimit* Action::_internal_mutable_velocity_limit() {
  
  if (velocity_limit_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::SpeedLimit>(GetArena());
    velocity_limit_ = p;
  }
  return velocity_limit_;
}
inline ::NavMessage::SpeedLimit* Action::mutable_velocity_limit() {
  // @@protoc_insertion_point(field_mutable:NavMessage.Action.velocity_limit)
  return _internal_mutable_velocity_limit();
}
inline void Action::set_allocated_velocity_limit(::NavMessage::SpeedLimit* velocity_limit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete velocity_limit_;
  }
  if (velocity_limit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(velocity_limit);
    if (message_arena != submessage_arena) {
      velocity_limit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, velocity_limit, submessage_arena);
    }
    
  } else {
    
  }
  velocity_limit_ = velocity_limit;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.Action.velocity_limit)
}

// .NavMessage.SpeedLimit angular_limit = 6;
inline bool Action::_internal_has_angular_limit() const {
  return this != internal_default_instance() && angular_limit_ != nullptr;
}
inline bool Action::has_angular_limit() const {
  return _internal_has_angular_limit();
}
inline void Action::clear_angular_limit() {
  if (GetArena() == nullptr && angular_limit_ != nullptr) {
    delete angular_limit_;
  }
  angular_limit_ = nullptr;
}
inline const ::NavMessage::SpeedLimit& Action::_internal_angular_limit() const {
  const ::NavMessage::SpeedLimit* p = angular_limit_;
  return p != nullptr ? *p : *reinterpret_cast<const ::NavMessage::SpeedLimit*>(
      &::NavMessage::_SpeedLimit_default_instance_);
}
inline const ::NavMessage::SpeedLimit& Action::angular_limit() const {
  // @@protoc_insertion_point(field_get:NavMessage.Action.angular_limit)
  return _internal_angular_limit();
}
inline void Action::unsafe_arena_set_allocated_angular_limit(
    ::NavMessage::SpeedLimit* angular_limit) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(angular_limit_);
  }
  angular_limit_ = angular_limit;
  if (angular_limit) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.Action.angular_limit)
}
inline ::NavMessage::SpeedLimit* Action::release_angular_limit() {
  
  ::NavMessage::SpeedLimit* temp = angular_limit_;
  angular_limit_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::SpeedLimit* Action::unsafe_arena_release_angular_limit() {
  // @@protoc_insertion_point(field_release:NavMessage.Action.angular_limit)
  
  ::NavMessage::SpeedLimit* temp = angular_limit_;
  angular_limit_ = nullptr;
  return temp;
}
inline ::NavMessage::SpeedLimit* Action::_internal_mutable_angular_limit() {
  
  if (angular_limit_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::SpeedLimit>(GetArena());
    angular_limit_ = p;
  }
  return angular_limit_;
}
inline ::NavMessage::SpeedLimit* Action::mutable_angular_limit() {
  // @@protoc_insertion_point(field_mutable:NavMessage.Action.angular_limit)
  return _internal_mutable_angular_limit();
}
inline void Action::set_allocated_angular_limit(::NavMessage::SpeedLimit* angular_limit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete angular_limit_;
  }
  if (angular_limit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(angular_limit);
    if (message_arena != submessage_arena) {
      angular_limit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, angular_limit, submessage_arena);
    }
    
  } else {
    
  }
  angular_limit_ = angular_limit;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.Action.angular_limit)
}

// .NavMessage.SpeedLimit horize_limit = 7;
inline bool Action::_internal_has_horize_limit() const {
  return this != internal_default_instance() && horize_limit_ != nullptr;
}
inline bool Action::has_horize_limit() const {
  return _internal_has_horize_limit();
}
inline void Action::clear_horize_limit() {
  if (GetArena() == nullptr && horize_limit_ != nullptr) {
    delete horize_limit_;
  }
  horize_limit_ = nullptr;
}
inline const ::NavMessage::SpeedLimit& Action::_internal_horize_limit() const {
  const ::NavMessage::SpeedLimit* p = horize_limit_;
  return p != nullptr ? *p : *reinterpret_cast<const ::NavMessage::SpeedLimit*>(
      &::NavMessage::_SpeedLimit_default_instance_);
}
inline const ::NavMessage::SpeedLimit& Action::horize_limit() const {
  // @@protoc_insertion_point(field_get:NavMessage.Action.horize_limit)
  return _internal_horize_limit();
}
inline void Action::unsafe_arena_set_allocated_horize_limit(
    ::NavMessage::SpeedLimit* horize_limit) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(horize_limit_);
  }
  horize_limit_ = horize_limit;
  if (horize_limit) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.Action.horize_limit)
}
inline ::NavMessage::SpeedLimit* Action::release_horize_limit() {
  
  ::NavMessage::SpeedLimit* temp = horize_limit_;
  horize_limit_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::SpeedLimit* Action::unsafe_arena_release_horize_limit() {
  // @@protoc_insertion_point(field_release:NavMessage.Action.horize_limit)
  
  ::NavMessage::SpeedLimit* temp = horize_limit_;
  horize_limit_ = nullptr;
  return temp;
}
inline ::NavMessage::SpeedLimit* Action::_internal_mutable_horize_limit() {
  
  if (horize_limit_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::SpeedLimit>(GetArena());
    horize_limit_ = p;
  }
  return horize_limit_;
}
inline ::NavMessage::SpeedLimit* Action::mutable_horize_limit() {
  // @@protoc_insertion_point(field_mutable:NavMessage.Action.horize_limit)
  return _internal_mutable_horize_limit();
}
inline void Action::set_allocated_horize_limit(::NavMessage::SpeedLimit* horize_limit) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete horize_limit_;
  }
  if (horize_limit) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(horize_limit);
    if (message_arena != submessage_arena) {
      horize_limit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, horize_limit, submessage_arena);
    }
    
  } else {
    
  }
  horize_limit_ = horize_limit;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.Action.horize_limit)
}

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

// NavCmd

// int32 action = 1;
inline void NavCmd::clear_action() {
  action_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 NavCmd::_internal_action() const {
  return action_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 NavCmd::action() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavCmd.action)
  return _internal_action();
}
inline void NavCmd::_internal_set_action(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  action_ = value;
}
inline void NavCmd::set_action(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:NavMessage.NavCmd.action)
}

// string key = 2;
inline void NavCmd::clear_key() {
  key_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline const std::string& NavCmd::key() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavCmd.key)
  return _internal_key();
}
inline void NavCmd::set_key(const std::string& value) {
  _internal_set_key(value);
  // @@protoc_insertion_point(field_set:NavMessage.NavCmd.key)
}
inline std::string* NavCmd::mutable_key() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NavCmd.key)
  return _internal_mutable_key();
}
inline const std::string& NavCmd::_internal_key() const {
  return key_.Get();
}
inline void NavCmd::_internal_set_key(const std::string& value) {
  
  key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void NavCmd::set_key(std::string&& value) {
  
  key_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:NavMessage.NavCmd.key)
}
inline void NavCmd::set_key(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:NavMessage.NavCmd.key)
}
inline void NavCmd::set_key(const char* value,
    size_t size) {
  
  key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:NavMessage.NavCmd.key)
}
inline std::string* NavCmd::_internal_mutable_key() {
  
  return key_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* NavCmd::release_key() {
  // @@protoc_insertion_point(field_release:NavMessage.NavCmd.key)
  return key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void NavCmd::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NavCmd.key)
}

// repeated .NavMessage.Action actions = 3;
inline int NavCmd::_internal_actions_size() const {
  return actions_.size();
}
inline int NavCmd::actions_size() const {
  return _internal_actions_size();
}
inline void NavCmd::clear_actions() {
  actions_.Clear();
}
inline ::NavMessage::Action* NavCmd::mutable_actions(int index) {
  // @@protoc_insertion_point(field_mutable:NavMessage.NavCmd.actions)
  return actions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Action >*
NavCmd::mutable_actions() {
  // @@protoc_insertion_point(field_mutable_list:NavMessage.NavCmd.actions)
  return &actions_;
}
inline const ::NavMessage::Action& NavCmd::_internal_actions(int index) const {
  return actions_.Get(index);
}
inline const ::NavMessage::Action& NavCmd::actions(int index) const {
  // @@protoc_insertion_point(field_get:NavMessage.NavCmd.actions)
  return _internal_actions(index);
}
inline ::NavMessage::Action* NavCmd::_internal_add_actions() {
  return actions_.Add();
}
inline ::NavMessage::Action* NavCmd::add_actions() {
  // @@protoc_insertion_point(field_add:NavMessage.NavCmd.actions)
  return _internal_add_actions();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Action >&
NavCmd::actions() const {
  // @@protoc_insertion_point(field_list:NavMessage.NavCmd.actions)
  return actions_;
}

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

// NavStatu

// bool statu = 1;
inline void NavStatu::clear_statu() {
  statu_ = false;
}
inline bool NavStatu::_internal_statu() const {
  return statu_;
}
inline bool NavStatu::statu() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavStatu.statu)
  return _internal_statu();
}
inline void NavStatu::_internal_set_statu(bool value) {
  
  statu_ = value;
}
inline void NavStatu::set_statu(bool value) {
  _internal_set_statu(value);
  // @@protoc_insertion_point(field_set:NavMessage.NavStatu.statu)
}

// string key = 2;
inline void NavStatu::clear_key() {
  key_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline const std::string& NavStatu::key() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavStatu.key)
  return _internal_key();
}
inline void NavStatu::set_key(const std::string& value) {
  _internal_set_key(value);
  // @@protoc_insertion_point(field_set:NavMessage.NavStatu.key)
}
inline std::string* NavStatu::mutable_key() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NavStatu.key)
  return _internal_mutable_key();
}
inline const std::string& NavStatu::_internal_key() const {
  return key_.Get();
}
inline void NavStatu::_internal_set_key(const std::string& value) {
  
  key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void NavStatu::set_key(std::string&& value) {
  
  key_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:NavMessage.NavStatu.key)
}
inline void NavStatu::set_key(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:NavMessage.NavStatu.key)
}
inline void NavStatu::set_key(const char* value,
    size_t size) {
  
  key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:NavMessage.NavStatu.key)
}
inline std::string* NavStatu::_internal_mutable_key() {
  
  return key_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* NavStatu::release_key() {
  // @@protoc_insertion_point(field_release:NavMessage.NavStatu.key)
  return key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void NavStatu::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NavStatu.key)
}

// repeated .NavMessage.Action unfinished_actions = 3;
inline int NavStatu::_internal_unfinished_actions_size() const {
  return unfinished_actions_.size();
}
inline int NavStatu::unfinished_actions_size() const {
  return _internal_unfinished_actions_size();
}
inline void NavStatu::clear_unfinished_actions() {
  unfinished_actions_.Clear();
}
inline ::NavMessage::Action* NavStatu::mutable_unfinished_actions(int index) {
  // @@protoc_insertion_point(field_mutable:NavMessage.NavStatu.unfinished_actions)
  return unfinished_actions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Action >*
NavStatu::mutable_unfinished_actions() {
  // @@protoc_insertion_point(field_mutable_list:NavMessage.NavStatu.unfinished_actions)
  return &unfinished_actions_;
}
inline const ::NavMessage::Action& NavStatu::_internal_unfinished_actions(int index) const {
  return unfinished_actions_.Get(index);
}
inline const ::NavMessage::Action& NavStatu::unfinished_actions(int index) const {
  // @@protoc_insertion_point(field_get:NavMessage.NavStatu.unfinished_actions)
  return _internal_unfinished_actions(index);
}
inline ::NavMessage::Action* NavStatu::_internal_add_unfinished_actions() {
  return unfinished_actions_.Add();
}
inline ::NavMessage::Action* NavStatu::add_unfinished_actions() {
  // @@protoc_insertion_point(field_add:NavMessage.NavStatu.unfinished_actions)
  return _internal_add_unfinished_actions();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::NavMessage::Action >&
NavStatu::unfinished_actions() const {
  // @@protoc_insertion_point(field_list:NavMessage.NavStatu.unfinished_actions)
  return unfinished_actions_;
}

// .NavMessage.Trajectory selected_traj = 4;
inline bool NavStatu::_internal_has_selected_traj() const {
  return this != internal_default_instance() && selected_traj_ != nullptr;
}
inline bool NavStatu::has_selected_traj() const {
  return _internal_has_selected_traj();
}
inline void NavStatu::clear_selected_traj() {
  if (GetArena() == nullptr && selected_traj_ != nullptr) {
    delete selected_traj_;
  }
  selected_traj_ = nullptr;
}
inline const ::NavMessage::Trajectory& NavStatu::_internal_selected_traj() const {
  const ::NavMessage::Trajectory* p = selected_traj_;
  return p != nullptr ? *p : *reinterpret_cast<const ::NavMessage::Trajectory*>(
      &::NavMessage::_Trajectory_default_instance_);
}
inline const ::NavMessage::Trajectory& NavStatu::selected_traj() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavStatu.selected_traj)
  return _internal_selected_traj();
}
inline void NavStatu::unsafe_arena_set_allocated_selected_traj(
    ::NavMessage::Trajectory* selected_traj) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(selected_traj_);
  }
  selected_traj_ = selected_traj;
  if (selected_traj) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NavStatu.selected_traj)
}
inline ::NavMessage::Trajectory* NavStatu::release_selected_traj() {
  
  ::NavMessage::Trajectory* temp = selected_traj_;
  selected_traj_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::Trajectory* NavStatu::unsafe_arena_release_selected_traj() {
  // @@protoc_insertion_point(field_release:NavMessage.NavStatu.selected_traj)
  
  ::NavMessage::Trajectory* temp = selected_traj_;
  selected_traj_ = nullptr;
  return temp;
}
inline ::NavMessage::Trajectory* NavStatu::_internal_mutable_selected_traj() {
  
  if (selected_traj_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::Trajectory>(GetArena());
    selected_traj_ = p;
  }
  return selected_traj_;
}
inline ::NavMessage::Trajectory* NavStatu::mutable_selected_traj() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NavStatu.selected_traj)
  return _internal_mutable_selected_traj();
}
inline void NavStatu::set_allocated_selected_traj(::NavMessage::Trajectory* selected_traj) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete selected_traj_;
  }
  if (selected_traj) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(selected_traj);
    if (message_arena != submessage_arena) {
      selected_traj = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, selected_traj, submessage_arena);
    }
    
  } else {
    
  }
  selected_traj_ = selected_traj;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NavStatu.selected_traj)
}

// .NavMessage.Trajectory predict_traj = 5;
inline bool NavStatu::_internal_has_predict_traj() const {
  return this != internal_default_instance() && predict_traj_ != nullptr;
}
inline bool NavStatu::has_predict_traj() const {
  return _internal_has_predict_traj();
}
inline void NavStatu::clear_predict_traj() {
  if (GetArena() == nullptr && predict_traj_ != nullptr) {
    delete predict_traj_;
  }
  predict_traj_ = nullptr;
}
inline const ::NavMessage::Trajectory& NavStatu::_internal_predict_traj() const {
  const ::NavMessage::Trajectory* p = predict_traj_;
  return p != nullptr ? *p : *reinterpret_cast<const ::NavMessage::Trajectory*>(
      &::NavMessage::_Trajectory_default_instance_);
}
inline const ::NavMessage::Trajectory& NavStatu::predict_traj() const {
  // @@protoc_insertion_point(field_get:NavMessage.NavStatu.predict_traj)
  return _internal_predict_traj();
}
inline void NavStatu::unsafe_arena_set_allocated_predict_traj(
    ::NavMessage::Trajectory* predict_traj) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(predict_traj_);
  }
  predict_traj_ = predict_traj;
  if (predict_traj) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:NavMessage.NavStatu.predict_traj)
}
inline ::NavMessage::Trajectory* NavStatu::release_predict_traj() {
  
  ::NavMessage::Trajectory* temp = predict_traj_;
  predict_traj_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::NavMessage::Trajectory* NavStatu::unsafe_arena_release_predict_traj() {
  // @@protoc_insertion_point(field_release:NavMessage.NavStatu.predict_traj)
  
  ::NavMessage::Trajectory* temp = predict_traj_;
  predict_traj_ = nullptr;
  return temp;
}
inline ::NavMessage::Trajectory* NavStatu::_internal_mutable_predict_traj() {
  
  if (predict_traj_ == nullptr) {
    auto* p = CreateMaybeMessage<::NavMessage::Trajectory>(GetArena());
    predict_traj_ = p;
  }
  return predict_traj_;
}
inline ::NavMessage::Trajectory* NavStatu::mutable_predict_traj() {
  // @@protoc_insertion_point(field_mutable:NavMessage.NavStatu.predict_traj)
  return _internal_mutable_predict_traj();
}
inline void NavStatu::set_allocated_predict_traj(::NavMessage::Trajectory* predict_traj) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete predict_traj_;
  }
  if (predict_traj) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(predict_traj);
    if (message_arena != submessage_arena) {
      predict_traj = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, predict_traj, submessage_arena);
    }
    
  } else {
    
  }
  predict_traj_ = predict_traj;
  // @@protoc_insertion_point(field_set_allocated:NavMessage.NavStatu.predict_traj)
}

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace NavMessage

// @@protoc_insertion_point(global_scope)

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