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

#ifndef PROTOBUF_INCLUDED_osmap_2eproto
#define PROTOBUF_INCLUDED_osmap_2eproto

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3006001
#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 3006001 < GOOGLE_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/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.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)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_osmap_2eproto 

namespace protobuf_osmap_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[13];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_osmap_2eproto
class SerializedDescriptor;
class SerializedDescriptorDefaultTypeInternal;
extern SerializedDescriptorDefaultTypeInternal _SerializedDescriptor_default_instance_;
class SerializedFeature;
class SerializedFeatureDefaultTypeInternal;
extern SerializedFeatureDefaultTypeInternal _SerializedFeature_default_instance_;
class SerializedK;
class SerializedKDefaultTypeInternal;
extern SerializedKDefaultTypeInternal _SerializedK_default_instance_;
class SerializedKArray;
class SerializedKArrayDefaultTypeInternal;
extern SerializedKArrayDefaultTypeInternal _SerializedKArray_default_instance_;
class SerializedKeyframe;
class SerializedKeyframeDefaultTypeInternal;
extern SerializedKeyframeDefaultTypeInternal _SerializedKeyframe_default_instance_;
class SerializedKeyframeArray;
class SerializedKeyframeArrayDefaultTypeInternal;
extern SerializedKeyframeArrayDefaultTypeInternal _SerializedKeyframeArray_default_instance_;
class SerializedKeyframeFeatures;
class SerializedKeyframeFeaturesDefaultTypeInternal;
extern SerializedKeyframeFeaturesDefaultTypeInternal _SerializedKeyframeFeatures_default_instance_;
class SerializedKeyframeFeaturesArray;
class SerializedKeyframeFeaturesArrayDefaultTypeInternal;
extern SerializedKeyframeFeaturesArrayDefaultTypeInternal _SerializedKeyframeFeaturesArray_default_instance_;
class SerializedKeypoint;
class SerializedKeypointDefaultTypeInternal;
extern SerializedKeypointDefaultTypeInternal _SerializedKeypoint_default_instance_;
class SerializedMappoint;
class SerializedMappointDefaultTypeInternal;
extern SerializedMappointDefaultTypeInternal _SerializedMappoint_default_instance_;
class SerializedMappointArray;
class SerializedMappointArrayDefaultTypeInternal;
extern SerializedMappointArrayDefaultTypeInternal _SerializedMappointArray_default_instance_;
class SerializedPose;
class SerializedPoseDefaultTypeInternal;
extern SerializedPoseDefaultTypeInternal _SerializedPose_default_instance_;
class SerializedPosition;
class SerializedPositionDefaultTypeInternal;
extern SerializedPositionDefaultTypeInternal _SerializedPosition_default_instance_;
namespace google {
namespace protobuf {
template<> ::SerializedDescriptor* Arena::CreateMaybeMessage<::SerializedDescriptor>(Arena*);
template<> ::SerializedFeature* Arena::CreateMaybeMessage<::SerializedFeature>(Arena*);
template<> ::SerializedK* Arena::CreateMaybeMessage<::SerializedK>(Arena*);
template<> ::SerializedKArray* Arena::CreateMaybeMessage<::SerializedKArray>(Arena*);
template<> ::SerializedKeyframe* Arena::CreateMaybeMessage<::SerializedKeyframe>(Arena*);
template<> ::SerializedKeyframeArray* Arena::CreateMaybeMessage<::SerializedKeyframeArray>(Arena*);
template<> ::SerializedKeyframeFeatures* Arena::CreateMaybeMessage<::SerializedKeyframeFeatures>(Arena*);
template<> ::SerializedKeyframeFeaturesArray* Arena::CreateMaybeMessage<::SerializedKeyframeFeaturesArray>(Arena*);
template<> ::SerializedKeypoint* Arena::CreateMaybeMessage<::SerializedKeypoint>(Arena*);
template<> ::SerializedMappoint* Arena::CreateMaybeMessage<::SerializedMappoint>(Arena*);
template<> ::SerializedMappointArray* Arena::CreateMaybeMessage<::SerializedMappointArray>(Arena*);
template<> ::SerializedPose* Arena::CreateMaybeMessage<::SerializedPose>(Arena*);
template<> ::SerializedPosition* Arena::CreateMaybeMessage<::SerializedPosition>(Arena*);
}  // namespace protobuf
}  // namespace google

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

class SerializedDescriptor : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:SerializedDescriptor) */ {
 public:
  SerializedDescriptor();
  virtual ~SerializedDescriptor();

  SerializedDescriptor(const SerializedDescriptor& from);

  inline SerializedDescriptor& operator=(const SerializedDescriptor& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SerializedDescriptor(SerializedDescriptor&& from) noexcept
    : SerializedDescriptor() {
    *this = ::std::move(from);
  }

  inline SerializedDescriptor& operator=(SerializedDescriptor&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SerializedDescriptor& default_instance();

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

  void Swap(SerializedDescriptor* other);
  friend void swap(SerializedDescriptor& a, SerializedDescriptor& b) {
    a.Swap(&b);
  }

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

  inline SerializedDescriptor* New() const final {
    return CreateMaybeMessage<SerializedDescriptor>(NULL);
  }

  SerializedDescriptor* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SerializedDescriptor>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SerializedDescriptor& from);
  void MergeFrom(const SerializedDescriptor& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SerializedDescriptor* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated fixed32 block = 1;
  int block_size() const;
  void clear_block();
  static const int kBlockFieldNumber = 1;
  ::google::protobuf::uint32 block(int index) const;
  void set_block(int index, ::google::protobuf::uint32 value);
  void add_block(::google::protobuf::uint32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      block() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_block();

  // @@protoc_insertion_point(class_scope:SerializedDescriptor)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > block_;
  mutable int _block_cached_byte_size_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_osmap_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SerializedPose : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:SerializedPose) */ {
 public:
  SerializedPose();
  virtual ~SerializedPose();

  SerializedPose(const SerializedPose& from);

  inline SerializedPose& operator=(const SerializedPose& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SerializedPose(SerializedPose&& from) noexcept
    : SerializedPose() {
    *this = ::std::move(from);
  }

  inline SerializedPose& operator=(SerializedPose&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SerializedPose& default_instance();

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

  void Swap(SerializedPose* other);
  friend void swap(SerializedPose& a, SerializedPose& b) {
    a.Swap(&b);
  }

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

  inline SerializedPose* New() const final {
    return CreateMaybeMessage<SerializedPose>(NULL);
  }

  SerializedPose* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SerializedPose>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SerializedPose& from);
  void MergeFrom(const SerializedPose& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SerializedPose* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated float element = 1;
  int element_size() const;
  void clear_element();
  static const int kElementFieldNumber = 1;
  float element(int index) const;
  void set_element(int index, float value);
  void add_element(float value);
  const ::google::protobuf::RepeatedField< float >&
      element() const;
  ::google::protobuf::RepeatedField< float >*
      mutable_element();

  // @@protoc_insertion_point(class_scope:SerializedPose)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< float > element_;
  mutable int _element_cached_byte_size_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_osmap_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SerializedPosition : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:SerializedPosition) */ {
 public:
  SerializedPosition();
  virtual ~SerializedPosition();

  SerializedPosition(const SerializedPosition& from);

  inline SerializedPosition& operator=(const SerializedPosition& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SerializedPosition(SerializedPosition&& from) noexcept
    : SerializedPosition() {
    *this = ::std::move(from);
  }

  inline SerializedPosition& operator=(SerializedPosition&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SerializedPosition& default_instance();

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

  void Swap(SerializedPosition* other);
  friend void swap(SerializedPosition& a, SerializedPosition& b) {
    a.Swap(&b);
  }

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

  inline SerializedPosition* New() const final {
    return CreateMaybeMessage<SerializedPosition>(NULL);
  }

  SerializedPosition* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SerializedPosition>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SerializedPosition& from);
  void MergeFrom(const SerializedPosition& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SerializedPosition* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // float x = 1;
  void clear_x();
  static const int kXFieldNumber = 1;
  float x() const;
  void set_x(float value);

  // float y = 2;
  void clear_y();
  static const int kYFieldNumber = 2;
  float y() const;
  void set_y(float value);

  // float z = 3;
  void clear_z();
  static const int kZFieldNumber = 3;
  float z() const;
  void set_z(float value);

  // @@protoc_insertion_point(class_scope:SerializedPosition)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  float x_;
  float y_;
  float z_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_osmap_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SerializedKeypoint : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:SerializedKeypoint) */ {
 public:
  SerializedKeypoint();
  virtual ~SerializedKeypoint();

  SerializedKeypoint(const SerializedKeypoint& from);

  inline SerializedKeypoint& operator=(const SerializedKeypoint& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SerializedKeypoint(SerializedKeypoint&& from) noexcept
    : SerializedKeypoint() {
    *this = ::std::move(from);
  }

  inline SerializedKeypoint& operator=(SerializedKeypoint&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SerializedKeypoint& default_instance();

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

  void Swap(SerializedKeypoint* other);
  friend void swap(SerializedKeypoint& a, SerializedKeypoint& b) {
    a.Swap(&b);
  }

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

  inline SerializedKeypoint* New() const final {
    return CreateMaybeMessage<SerializedKeypoint>(NULL);
  }

  SerializedKeypoint* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SerializedKeypoint>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SerializedKeypoint& from);
  void MergeFrom(const SerializedKeypoint& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SerializedKeypoint* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // float ptx = 1;
  void clear_ptx();
  static const int kPtxFieldNumber = 1;
  float ptx() const;
  void set_ptx(float value);

  // float pty = 2;
  void clear_pty();
  static const int kPtyFieldNumber = 2;
  float pty() const;
  void set_pty(float value);

  // float angle = 3;
  void clear_angle();
  static const int kAngleFieldNumber = 3;
  float angle() const;
  void set_angle(float value);

  // float octave = 4;
  void clear_octave();
  static const int kOctaveFieldNumber = 4;
  float octave() const;
  void set_octave(float value);

  // @@protoc_insertion_point(class_scope:SerializedKeypoint)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  float ptx_;
  float pty_;
  float angle_;
  float octave_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_osmap_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SerializedK : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:SerializedK) */ {
 public:
  SerializedK();
  virtual ~SerializedK();

  SerializedK(const SerializedK& from);

  inline SerializedK& operator=(const SerializedK& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SerializedK(SerializedK&& from) noexcept
    : SerializedK() {
    *this = ::std::move(from);
  }

  inline SerializedK& operator=(SerializedK&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SerializedK& default_instance();

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

  void Swap(SerializedK* other);
  friend void swap(SerializedK& a, SerializedK& b) {
    a.Swap(&b);
  }

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

  inline SerializedK* New() const final {
    return CreateMaybeMessage<SerializedK>(NULL);
  }

  SerializedK* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SerializedK>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SerializedK& from);
  void MergeFrom(const SerializedK& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SerializedK* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // float fx = 1;
  void clear_fx();
  static const int kFxFieldNumber = 1;
  float fx() const;
  void set_fx(float value);

  // float fy = 2;
  void clear_fy();
  static const int kFyFieldNumber = 2;
  float fy() const;
  void set_fy(float value);

  // float cx = 3;
  void clear_cx();
  static const int kCxFieldNumber = 3;
  float cx() const;
  void set_cx(float value);

  // float cy = 4;
  void clear_cy();
  static const int kCyFieldNumber = 4;
  float cy() const;
  void set_cy(float value);

  // @@protoc_insertion_point(class_scope:SerializedK)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  float fx_;
  float fy_;
  float cx_;
  float cy_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_osmap_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SerializedKArray : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:SerializedKArray) */ {
 public:
  SerializedKArray();
  virtual ~SerializedKArray();

  SerializedKArray(const SerializedKArray& from);

  inline SerializedKArray& operator=(const SerializedKArray& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SerializedKArray(SerializedKArray&& from) noexcept
    : SerializedKArray() {
    *this = ::std::move(from);
  }

  inline SerializedKArray& operator=(SerializedKArray&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SerializedKArray& default_instance();

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

  void Swap(SerializedKArray* other);
  friend void swap(SerializedKArray& a, SerializedKArray& b) {
    a.Swap(&b);
  }

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

  inline SerializedKArray* New() const final {
    return CreateMaybeMessage<SerializedKArray>(NULL);
  }

  SerializedKArray* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SerializedKArray>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SerializedKArray& from);
  void MergeFrom(const SerializedKArray& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SerializedKArray* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated .SerializedK k = 1;
  int k_size() const;
  void clear_k();
  static const int kKFieldNumber = 1;
  ::SerializedK* mutable_k(int index);
  ::google::protobuf::RepeatedPtrField< ::SerializedK >*
      mutable_k();
  const ::SerializedK& k(int index) const;
  ::SerializedK* add_k();
  const ::google::protobuf::RepeatedPtrField< ::SerializedK >&
      k() const;

  // @@protoc_insertion_point(class_scope:SerializedKArray)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::SerializedK > k_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_osmap_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SerializedMappoint : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:SerializedMappoint) */ {
 public:
  SerializedMappoint();
  virtual ~SerializedMappoint();

  SerializedMappoint(const SerializedMappoint& from);

  inline SerializedMappoint& operator=(const SerializedMappoint& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SerializedMappoint(SerializedMappoint&& from) noexcept
    : SerializedMappoint() {
    *this = ::std::move(from);
  }

  inline SerializedMappoint& operator=(SerializedMappoint&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SerializedMappoint& default_instance();

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

  void Swap(SerializedMappoint* other);
  friend void swap(SerializedMappoint& a, SerializedMappoint& b) {
    a.Swap(&b);
  }

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

  inline SerializedMappoint* New() const final {
    return CreateMaybeMessage<SerializedMappoint>(NULL);
  }

  SerializedMappoint* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SerializedMappoint>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SerializedMappoint& from);
  void MergeFrom(const SerializedMappoint& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SerializedMappoint* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // .SerializedPosition position = 2;
  bool has_position() const;
  void clear_position();
  static const int kPositionFieldNumber = 2;
  private:
  const ::SerializedPosition& _internal_position() const;
  public:
  const ::SerializedPosition& position() const;
  ::SerializedPosition* release_position();
  ::SerializedPosition* mutable_position();
  void set_allocated_position(::SerializedPosition* position);

  // .SerializedDescriptor briefdescriptor = 5;
  bool has_briefdescriptor() const;
  void clear_briefdescriptor();
  static const int kBriefdescriptorFieldNumber = 5;
  private:
  const ::SerializedDescriptor& _internal_briefdescriptor() const;
  public:
  const ::SerializedDescriptor& briefdescriptor() const;
  ::SerializedDescriptor* release_briefdescriptor();
  ::SerializedDescriptor* mutable_briefdescriptor();
  void set_allocated_briefdescriptor(::SerializedDescriptor* briefdescriptor);

  // uint32 id = 1;
  void clear_id();
  static const int kIdFieldNumber = 1;
  ::google::protobuf::uint32 id() const;
  void set_id(::google::protobuf::uint32 value);

  // float visible = 3;
  void clear_visible();
  static const int kVisibleFieldNumber = 3;
  float visible() const;
  void set_visible(float value);

  // float found = 4;
  void clear_found();
  static const int kFoundFieldNumber = 4;
  float found() const;
  void set_found(float value);

  // @@protoc_insertion_point(class_scope:SerializedMappoint)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::SerializedPosition* position_;
  ::SerializedDescriptor* briefdescriptor_;
  ::google::protobuf::uint32 id_;
  float visible_;
  float found_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_osmap_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SerializedMappointArray : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:SerializedMappointArray) */ {
 public:
  SerializedMappointArray();
  virtual ~SerializedMappointArray();

  SerializedMappointArray(const SerializedMappointArray& from);

  inline SerializedMappointArray& operator=(const SerializedMappointArray& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SerializedMappointArray(SerializedMappointArray&& from) noexcept
    : SerializedMappointArray() {
    *this = ::std::move(from);
  }

  inline SerializedMappointArray& operator=(SerializedMappointArray&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SerializedMappointArray& default_instance();

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

  void Swap(SerializedMappointArray* other);
  friend void swap(SerializedMappointArray& a, SerializedMappointArray& b) {
    a.Swap(&b);
  }

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

  inline SerializedMappointArray* New() const final {
    return CreateMaybeMessage<SerializedMappointArray>(NULL);
  }

  SerializedMappointArray* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SerializedMappointArray>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SerializedMappointArray& from);
  void MergeFrom(const SerializedMappointArray& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SerializedMappointArray* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated .SerializedMappoint mappoint = 1;
  int mappoint_size() const;
  void clear_mappoint();
  static const int kMappointFieldNumber = 1;
  ::SerializedMappoint* mutable_mappoint(int index);
  ::google::protobuf::RepeatedPtrField< ::SerializedMappoint >*
      mutable_mappoint();
  const ::SerializedMappoint& mappoint(int index) const;
  ::SerializedMappoint* add_mappoint();
  const ::google::protobuf::RepeatedPtrField< ::SerializedMappoint >&
      mappoint() const;

  // @@protoc_insertion_point(class_scope:SerializedMappointArray)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::SerializedMappoint > mappoint_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_osmap_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SerializedKeyframe : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:SerializedKeyframe) */ {
 public:
  SerializedKeyframe();
  virtual ~SerializedKeyframe();

  SerializedKeyframe(const SerializedKeyframe& from);

  inline SerializedKeyframe& operator=(const SerializedKeyframe& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SerializedKeyframe(SerializedKeyframe&& from) noexcept
    : SerializedKeyframe() {
    *this = ::std::move(from);
  }

  inline SerializedKeyframe& operator=(SerializedKeyframe&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SerializedKeyframe& default_instance();

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

  void Swap(SerializedKeyframe* other);
  friend void swap(SerializedKeyframe& a, SerializedKeyframe& b) {
    a.Swap(&b);
  }

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

  inline SerializedKeyframe* New() const final {
    return CreateMaybeMessage<SerializedKeyframe>(NULL);
  }

  SerializedKeyframe* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SerializedKeyframe>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SerializedKeyframe& from);
  void MergeFrom(const SerializedKeyframe& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SerializedKeyframe* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated uint32 loopedgesids = 5;
  int loopedgesids_size() const;
  void clear_loopedgesids();
  static const int kLoopedgesidsFieldNumber = 5;
  ::google::protobuf::uint32 loopedgesids(int index) const;
  void set_loopedgesids(int index, ::google::protobuf::uint32 value);
  void add_loopedgesids(::google::protobuf::uint32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      loopedgesids() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_loopedgesids();

  // .SerializedPose pose = 2;
  bool has_pose() const;
  void clear_pose();
  static const int kPoseFieldNumber = 2;
  private:
  const ::SerializedPose& _internal_pose() const;
  public:
  const ::SerializedPose& pose() const;
  ::SerializedPose* release_pose();
  ::SerializedPose* mutable_pose();
  void set_allocated_pose(::SerializedPose* pose);

  // .SerializedK kmatrix = 3;
  bool has_kmatrix() const;
  void clear_kmatrix();
  static const int kKmatrixFieldNumber = 3;
  private:
  const ::SerializedK& _internal_kmatrix() const;
  public:
  const ::SerializedK& kmatrix() const;
  ::SerializedK* release_kmatrix();
  ::SerializedK* mutable_kmatrix();
  void set_allocated_kmatrix(::SerializedK* kmatrix);

  // uint32 id = 1;
  void clear_id();
  static const int kIdFieldNumber = 1;
  ::google::protobuf::uint32 id() const;
  void set_id(::google::protobuf::uint32 value);

  // uint32 kindex = 4;
  void clear_kindex();
  static const int kKindexFieldNumber = 4;
  ::google::protobuf::uint32 kindex() const;
  void set_kindex(::google::protobuf::uint32 value);

  // double timestamp = 6;
  void clear_timestamp();
  static const int kTimestampFieldNumber = 6;
  double timestamp() const;
  void set_timestamp(double value);

  // @@protoc_insertion_point(class_scope:SerializedKeyframe)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > loopedgesids_;
  mutable int _loopedgesids_cached_byte_size_;
  ::SerializedPose* pose_;
  ::SerializedK* kmatrix_;
  ::google::protobuf::uint32 id_;
  ::google::protobuf::uint32 kindex_;
  double timestamp_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_osmap_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SerializedKeyframeArray : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:SerializedKeyframeArray) */ {
 public:
  SerializedKeyframeArray();
  virtual ~SerializedKeyframeArray();

  SerializedKeyframeArray(const SerializedKeyframeArray& from);

  inline SerializedKeyframeArray& operator=(const SerializedKeyframeArray& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SerializedKeyframeArray(SerializedKeyframeArray&& from) noexcept
    : SerializedKeyframeArray() {
    *this = ::std::move(from);
  }

  inline SerializedKeyframeArray& operator=(SerializedKeyframeArray&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SerializedKeyframeArray& default_instance();

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

  void Swap(SerializedKeyframeArray* other);
  friend void swap(SerializedKeyframeArray& a, SerializedKeyframeArray& b) {
    a.Swap(&b);
  }

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

  inline SerializedKeyframeArray* New() const final {
    return CreateMaybeMessage<SerializedKeyframeArray>(NULL);
  }

  SerializedKeyframeArray* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SerializedKeyframeArray>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SerializedKeyframeArray& from);
  void MergeFrom(const SerializedKeyframeArray& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SerializedKeyframeArray* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated .SerializedKeyframe keyframe = 1;
  int keyframe_size() const;
  void clear_keyframe();
  static const int kKeyframeFieldNumber = 1;
  ::SerializedKeyframe* mutable_keyframe(int index);
  ::google::protobuf::RepeatedPtrField< ::SerializedKeyframe >*
      mutable_keyframe();
  const ::SerializedKeyframe& keyframe(int index) const;
  ::SerializedKeyframe* add_keyframe();
  const ::google::protobuf::RepeatedPtrField< ::SerializedKeyframe >&
      keyframe() const;

  // @@protoc_insertion_point(class_scope:SerializedKeyframeArray)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::SerializedKeyframe > keyframe_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_osmap_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SerializedFeature : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:SerializedFeature) */ {
 public:
  SerializedFeature();
  virtual ~SerializedFeature();

  SerializedFeature(const SerializedFeature& from);

  inline SerializedFeature& operator=(const SerializedFeature& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SerializedFeature(SerializedFeature&& from) noexcept
    : SerializedFeature() {
    *this = ::std::move(from);
  }

  inline SerializedFeature& operator=(SerializedFeature&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SerializedFeature& default_instance();

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

  void Swap(SerializedFeature* other);
  friend void swap(SerializedFeature& a, SerializedFeature& b) {
    a.Swap(&b);
  }

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

  inline SerializedFeature* New() const final {
    return CreateMaybeMessage<SerializedFeature>(NULL);
  }

  SerializedFeature* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SerializedFeature>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SerializedFeature& from);
  void MergeFrom(const SerializedFeature& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SerializedFeature* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // .SerializedKeypoint keypoint = 3;
  bool has_keypoint() const;
  void clear_keypoint();
  static const int kKeypointFieldNumber = 3;
  private:
  const ::SerializedKeypoint& _internal_keypoint() const;
  public:
  const ::SerializedKeypoint& keypoint() const;
  ::SerializedKeypoint* release_keypoint();
  ::SerializedKeypoint* mutable_keypoint();
  void set_allocated_keypoint(::SerializedKeypoint* keypoint);

  // .SerializedDescriptor briefdescriptor = 4;
  bool has_briefdescriptor() const;
  void clear_briefdescriptor();
  static const int kBriefdescriptorFieldNumber = 4;
  private:
  const ::SerializedDescriptor& _internal_briefdescriptor() const;
  public:
  const ::SerializedDescriptor& briefdescriptor() const;
  ::SerializedDescriptor* release_briefdescriptor();
  ::SerializedDescriptor* mutable_briefdescriptor();
  void set_allocated_briefdescriptor(::SerializedDescriptor* briefdescriptor);

  // uint32 mappoint_id = 2;
  void clear_mappoint_id();
  static const int kMappointIdFieldNumber = 2;
  ::google::protobuf::uint32 mappoint_id() const;
  void set_mappoint_id(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:SerializedFeature)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::SerializedKeypoint* keypoint_;
  ::SerializedDescriptor* briefdescriptor_;
  ::google::protobuf::uint32 mappoint_id_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_osmap_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SerializedKeyframeFeatures : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:SerializedKeyframeFeatures) */ {
 public:
  SerializedKeyframeFeatures();
  virtual ~SerializedKeyframeFeatures();

  SerializedKeyframeFeatures(const SerializedKeyframeFeatures& from);

  inline SerializedKeyframeFeatures& operator=(const SerializedKeyframeFeatures& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SerializedKeyframeFeatures(SerializedKeyframeFeatures&& from) noexcept
    : SerializedKeyframeFeatures() {
    *this = ::std::move(from);
  }

  inline SerializedKeyframeFeatures& operator=(SerializedKeyframeFeatures&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SerializedKeyframeFeatures& default_instance();

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

  void Swap(SerializedKeyframeFeatures* other);
  friend void swap(SerializedKeyframeFeatures& a, SerializedKeyframeFeatures& b) {
    a.Swap(&b);
  }

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

  inline SerializedKeyframeFeatures* New() const final {
    return CreateMaybeMessage<SerializedKeyframeFeatures>(NULL);
  }

  SerializedKeyframeFeatures* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SerializedKeyframeFeatures>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SerializedKeyframeFeatures& from);
  void MergeFrom(const SerializedKeyframeFeatures& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SerializedKeyframeFeatures* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated .SerializedFeature feature = 2;
  int feature_size() const;
  void clear_feature();
  static const int kFeatureFieldNumber = 2;
  ::SerializedFeature* mutable_feature(int index);
  ::google::protobuf::RepeatedPtrField< ::SerializedFeature >*
      mutable_feature();
  const ::SerializedFeature& feature(int index) const;
  ::SerializedFeature* add_feature();
  const ::google::protobuf::RepeatedPtrField< ::SerializedFeature >&
      feature() const;

  // uint32 keyframe_id = 1;
  void clear_keyframe_id();
  static const int kKeyframeIdFieldNumber = 1;
  ::google::protobuf::uint32 keyframe_id() const;
  void set_keyframe_id(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:SerializedKeyframeFeatures)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::SerializedFeature > feature_;
  ::google::protobuf::uint32 keyframe_id_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_osmap_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SerializedKeyframeFeaturesArray : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:SerializedKeyframeFeaturesArray) */ {
 public:
  SerializedKeyframeFeaturesArray();
  virtual ~SerializedKeyframeFeaturesArray();

  SerializedKeyframeFeaturesArray(const SerializedKeyframeFeaturesArray& from);

  inline SerializedKeyframeFeaturesArray& operator=(const SerializedKeyframeFeaturesArray& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SerializedKeyframeFeaturesArray(SerializedKeyframeFeaturesArray&& from) noexcept
    : SerializedKeyframeFeaturesArray() {
    *this = ::std::move(from);
  }

  inline SerializedKeyframeFeaturesArray& operator=(SerializedKeyframeFeaturesArray&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SerializedKeyframeFeaturesArray& default_instance();

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

  void Swap(SerializedKeyframeFeaturesArray* other);
  friend void swap(SerializedKeyframeFeaturesArray& a, SerializedKeyframeFeaturesArray& b) {
    a.Swap(&b);
  }

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

  inline SerializedKeyframeFeaturesArray* New() const final {
    return CreateMaybeMessage<SerializedKeyframeFeaturesArray>(NULL);
  }

  SerializedKeyframeFeaturesArray* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SerializedKeyframeFeaturesArray>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SerializedKeyframeFeaturesArray& from);
  void MergeFrom(const SerializedKeyframeFeaturesArray& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SerializedKeyframeFeaturesArray* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

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

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

  // repeated .SerializedKeyframeFeatures feature = 1;
  int feature_size() const;
  void clear_feature();
  static const int kFeatureFieldNumber = 1;
  ::SerializedKeyframeFeatures* mutable_feature(int index);
  ::google::protobuf::RepeatedPtrField< ::SerializedKeyframeFeatures >*
      mutable_feature();
  const ::SerializedKeyframeFeatures& feature(int index) const;
  ::SerializedKeyframeFeatures* add_feature();
  const ::google::protobuf::RepeatedPtrField< ::SerializedKeyframeFeatures >&
      feature() const;

  // @@protoc_insertion_point(class_scope:SerializedKeyframeFeaturesArray)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::SerializedKeyframeFeatures > feature_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_osmap_2eproto::TableStruct;
};
// ===================================================================


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

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

// repeated fixed32 block = 1;
inline int SerializedDescriptor::block_size() const {
  return block_.size();
}
inline void SerializedDescriptor::clear_block() {
  block_.Clear();
}
inline ::google::protobuf::uint32 SerializedDescriptor::block(int index) const {
  // @@protoc_insertion_point(field_get:SerializedDescriptor.block)
  return block_.Get(index);
}
inline void SerializedDescriptor::set_block(int index, ::google::protobuf::uint32 value) {
  block_.Set(index, value);
  // @@protoc_insertion_point(field_set:SerializedDescriptor.block)
}
inline void SerializedDescriptor::add_block(::google::protobuf::uint32 value) {
  block_.Add(value);
  // @@protoc_insertion_point(field_add:SerializedDescriptor.block)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
SerializedDescriptor::block() const {
  // @@protoc_insertion_point(field_list:SerializedDescriptor.block)
  return block_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
SerializedDescriptor::mutable_block() {
  // @@protoc_insertion_point(field_mutable_list:SerializedDescriptor.block)
  return &block_;
}

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

// SerializedPose

// repeated float element = 1;
inline int SerializedPose::element_size() const {
  return element_.size();
}
inline void SerializedPose::clear_element() {
  element_.Clear();
}
inline float SerializedPose::element(int index) const {
  // @@protoc_insertion_point(field_get:SerializedPose.element)
  return element_.Get(index);
}
inline void SerializedPose::set_element(int index, float value) {
  element_.Set(index, value);
  // @@protoc_insertion_point(field_set:SerializedPose.element)
}
inline void SerializedPose::add_element(float value) {
  element_.Add(value);
  // @@protoc_insertion_point(field_add:SerializedPose.element)
}
inline const ::google::protobuf::RepeatedField< float >&
SerializedPose::element() const {
  // @@protoc_insertion_point(field_list:SerializedPose.element)
  return element_;
}
inline ::google::protobuf::RepeatedField< float >*
SerializedPose::mutable_element() {
  // @@protoc_insertion_point(field_mutable_list:SerializedPose.element)
  return &element_;
}

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

// SerializedPosition

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

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

// float z = 3;
inline void SerializedPosition::clear_z() {
  z_ = 0;
}
inline float SerializedPosition::z() const {
  // @@protoc_insertion_point(field_get:SerializedPosition.z)
  return z_;
}
inline void SerializedPosition::set_z(float value) {
  
  z_ = value;
  // @@protoc_insertion_point(field_set:SerializedPosition.z)
}

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

// SerializedKeypoint

// float ptx = 1;
inline void SerializedKeypoint::clear_ptx() {
  ptx_ = 0;
}
inline float SerializedKeypoint::ptx() const {
  // @@protoc_insertion_point(field_get:SerializedKeypoint.ptx)
  return ptx_;
}
inline void SerializedKeypoint::set_ptx(float value) {
  
  ptx_ = value;
  // @@protoc_insertion_point(field_set:SerializedKeypoint.ptx)
}

// float pty = 2;
inline void SerializedKeypoint::clear_pty() {
  pty_ = 0;
}
inline float SerializedKeypoint::pty() const {
  // @@protoc_insertion_point(field_get:SerializedKeypoint.pty)
  return pty_;
}
inline void SerializedKeypoint::set_pty(float value) {
  
  pty_ = value;
  // @@protoc_insertion_point(field_set:SerializedKeypoint.pty)
}

// float angle = 3;
inline void SerializedKeypoint::clear_angle() {
  angle_ = 0;
}
inline float SerializedKeypoint::angle() const {
  // @@protoc_insertion_point(field_get:SerializedKeypoint.angle)
  return angle_;
}
inline void SerializedKeypoint::set_angle(float value) {
  
  angle_ = value;
  // @@protoc_insertion_point(field_set:SerializedKeypoint.angle)
}

// float octave = 4;
inline void SerializedKeypoint::clear_octave() {
  octave_ = 0;
}
inline float SerializedKeypoint::octave() const {
  // @@protoc_insertion_point(field_get:SerializedKeypoint.octave)
  return octave_;
}
inline void SerializedKeypoint::set_octave(float value) {
  
  octave_ = value;
  // @@protoc_insertion_point(field_set:SerializedKeypoint.octave)
}

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

// SerializedK

// float fx = 1;
inline void SerializedK::clear_fx() {
  fx_ = 0;
}
inline float SerializedK::fx() const {
  // @@protoc_insertion_point(field_get:SerializedK.fx)
  return fx_;
}
inline void SerializedK::set_fx(float value) {
  
  fx_ = value;
  // @@protoc_insertion_point(field_set:SerializedK.fx)
}

// float fy = 2;
inline void SerializedK::clear_fy() {
  fy_ = 0;
}
inline float SerializedK::fy() const {
  // @@protoc_insertion_point(field_get:SerializedK.fy)
  return fy_;
}
inline void SerializedK::set_fy(float value) {
  
  fy_ = value;
  // @@protoc_insertion_point(field_set:SerializedK.fy)
}

// float cx = 3;
inline void SerializedK::clear_cx() {
  cx_ = 0;
}
inline float SerializedK::cx() const {
  // @@protoc_insertion_point(field_get:SerializedK.cx)
  return cx_;
}
inline void SerializedK::set_cx(float value) {
  
  cx_ = value;
  // @@protoc_insertion_point(field_set:SerializedK.cx)
}

// float cy = 4;
inline void SerializedK::clear_cy() {
  cy_ = 0;
}
inline float SerializedK::cy() const {
  // @@protoc_insertion_point(field_get:SerializedK.cy)
  return cy_;
}
inline void SerializedK::set_cy(float value) {
  
  cy_ = value;
  // @@protoc_insertion_point(field_set:SerializedK.cy)
}

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

// SerializedKArray

// repeated .SerializedK k = 1;
inline int SerializedKArray::k_size() const {
  return k_.size();
}
inline void SerializedKArray::clear_k() {
  k_.Clear();
}
inline ::SerializedK* SerializedKArray::mutable_k(int index) {
  // @@protoc_insertion_point(field_mutable:SerializedKArray.k)
  return k_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::SerializedK >*
SerializedKArray::mutable_k() {
  // @@protoc_insertion_point(field_mutable_list:SerializedKArray.k)
  return &k_;
}
inline const ::SerializedK& SerializedKArray::k(int index) const {
  // @@protoc_insertion_point(field_get:SerializedKArray.k)
  return k_.Get(index);
}
inline ::SerializedK* SerializedKArray::add_k() {
  // @@protoc_insertion_point(field_add:SerializedKArray.k)
  return k_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::SerializedK >&
SerializedKArray::k() const {
  // @@protoc_insertion_point(field_list:SerializedKArray.k)
  return k_;
}

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

// SerializedMappoint

// uint32 id = 1;
inline void SerializedMappoint::clear_id() {
  id_ = 0u;
}
inline ::google::protobuf::uint32 SerializedMappoint::id() const {
  // @@protoc_insertion_point(field_get:SerializedMappoint.id)
  return id_;
}
inline void SerializedMappoint::set_id(::google::protobuf::uint32 value) {
  
  id_ = value;
  // @@protoc_insertion_point(field_set:SerializedMappoint.id)
}

// .SerializedPosition position = 2;
inline bool SerializedMappoint::has_position() const {
  return this != internal_default_instance() && position_ != NULL;
}
inline void SerializedMappoint::clear_position() {
  if (GetArenaNoVirtual() == NULL && position_ != NULL) {
    delete position_;
  }
  position_ = NULL;
}
inline const ::SerializedPosition& SerializedMappoint::_internal_position() const {
  return *position_;
}
inline const ::SerializedPosition& SerializedMappoint::position() const {
  const ::SerializedPosition* p = position_;
  // @@protoc_insertion_point(field_get:SerializedMappoint.position)
  return p != NULL ? *p : *reinterpret_cast<const ::SerializedPosition*>(
      &::_SerializedPosition_default_instance_);
}
inline ::SerializedPosition* SerializedMappoint::release_position() {
  // @@protoc_insertion_point(field_release:SerializedMappoint.position)
  
  ::SerializedPosition* temp = position_;
  position_ = NULL;
  return temp;
}
inline ::SerializedPosition* SerializedMappoint::mutable_position() {
  
  if (position_ == NULL) {
    auto* p = CreateMaybeMessage<::SerializedPosition>(GetArenaNoVirtual());
    position_ = p;
  }
  // @@protoc_insertion_point(field_mutable:SerializedMappoint.position)
  return position_;
}
inline void SerializedMappoint::set_allocated_position(::SerializedPosition* position) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete position_;
  }
  if (position) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      position = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, position, submessage_arena);
    }
    
  } else {
    
  }
  position_ = position;
  // @@protoc_insertion_point(field_set_allocated:SerializedMappoint.position)
}

// float visible = 3;
inline void SerializedMappoint::clear_visible() {
  visible_ = 0;
}
inline float SerializedMappoint::visible() const {
  // @@protoc_insertion_point(field_get:SerializedMappoint.visible)
  return visible_;
}
inline void SerializedMappoint::set_visible(float value) {
  
  visible_ = value;
  // @@protoc_insertion_point(field_set:SerializedMappoint.visible)
}

// float found = 4;
inline void SerializedMappoint::clear_found() {
  found_ = 0;
}
inline float SerializedMappoint::found() const {
  // @@protoc_insertion_point(field_get:SerializedMappoint.found)
  return found_;
}
inline void SerializedMappoint::set_found(float value) {
  
  found_ = value;
  // @@protoc_insertion_point(field_set:SerializedMappoint.found)
}

// .SerializedDescriptor briefdescriptor = 5;
inline bool SerializedMappoint::has_briefdescriptor() const {
  return this != internal_default_instance() && briefdescriptor_ != NULL;
}
inline void SerializedMappoint::clear_briefdescriptor() {
  if (GetArenaNoVirtual() == NULL && briefdescriptor_ != NULL) {
    delete briefdescriptor_;
  }
  briefdescriptor_ = NULL;
}
inline const ::SerializedDescriptor& SerializedMappoint::_internal_briefdescriptor() const {
  return *briefdescriptor_;
}
inline const ::SerializedDescriptor& SerializedMappoint::briefdescriptor() const {
  const ::SerializedDescriptor* p = briefdescriptor_;
  // @@protoc_insertion_point(field_get:SerializedMappoint.briefdescriptor)
  return p != NULL ? *p : *reinterpret_cast<const ::SerializedDescriptor*>(
      &::_SerializedDescriptor_default_instance_);
}
inline ::SerializedDescriptor* SerializedMappoint::release_briefdescriptor() {
  // @@protoc_insertion_point(field_release:SerializedMappoint.briefdescriptor)
  
  ::SerializedDescriptor* temp = briefdescriptor_;
  briefdescriptor_ = NULL;
  return temp;
}
inline ::SerializedDescriptor* SerializedMappoint::mutable_briefdescriptor() {
  
  if (briefdescriptor_ == NULL) {
    auto* p = CreateMaybeMessage<::SerializedDescriptor>(GetArenaNoVirtual());
    briefdescriptor_ = p;
  }
  // @@protoc_insertion_point(field_mutable:SerializedMappoint.briefdescriptor)
  return briefdescriptor_;
}
inline void SerializedMappoint::set_allocated_briefdescriptor(::SerializedDescriptor* briefdescriptor) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete briefdescriptor_;
  }
  if (briefdescriptor) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      briefdescriptor = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, briefdescriptor, submessage_arena);
    }
    
  } else {
    
  }
  briefdescriptor_ = briefdescriptor;
  // @@protoc_insertion_point(field_set_allocated:SerializedMappoint.briefdescriptor)
}

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

// SerializedMappointArray

// repeated .SerializedMappoint mappoint = 1;
inline int SerializedMappointArray::mappoint_size() const {
  return mappoint_.size();
}
inline void SerializedMappointArray::clear_mappoint() {
  mappoint_.Clear();
}
inline ::SerializedMappoint* SerializedMappointArray::mutable_mappoint(int index) {
  // @@protoc_insertion_point(field_mutable:SerializedMappointArray.mappoint)
  return mappoint_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::SerializedMappoint >*
SerializedMappointArray::mutable_mappoint() {
  // @@protoc_insertion_point(field_mutable_list:SerializedMappointArray.mappoint)
  return &mappoint_;
}
inline const ::SerializedMappoint& SerializedMappointArray::mappoint(int index) const {
  // @@protoc_insertion_point(field_get:SerializedMappointArray.mappoint)
  return mappoint_.Get(index);
}
inline ::SerializedMappoint* SerializedMappointArray::add_mappoint() {
  // @@protoc_insertion_point(field_add:SerializedMappointArray.mappoint)
  return mappoint_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::SerializedMappoint >&
SerializedMappointArray::mappoint() const {
  // @@protoc_insertion_point(field_list:SerializedMappointArray.mappoint)
  return mappoint_;
}

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

// SerializedKeyframe

// uint32 id = 1;
inline void SerializedKeyframe::clear_id() {
  id_ = 0u;
}
inline ::google::protobuf::uint32 SerializedKeyframe::id() const {
  // @@protoc_insertion_point(field_get:SerializedKeyframe.id)
  return id_;
}
inline void SerializedKeyframe::set_id(::google::protobuf::uint32 value) {
  
  id_ = value;
  // @@protoc_insertion_point(field_set:SerializedKeyframe.id)
}

// .SerializedPose pose = 2;
inline bool SerializedKeyframe::has_pose() const {
  return this != internal_default_instance() && pose_ != NULL;
}
inline void SerializedKeyframe::clear_pose() {
  if (GetArenaNoVirtual() == NULL && pose_ != NULL) {
    delete pose_;
  }
  pose_ = NULL;
}
inline const ::SerializedPose& SerializedKeyframe::_internal_pose() const {
  return *pose_;
}
inline const ::SerializedPose& SerializedKeyframe::pose() const {
  const ::SerializedPose* p = pose_;
  // @@protoc_insertion_point(field_get:SerializedKeyframe.pose)
  return p != NULL ? *p : *reinterpret_cast<const ::SerializedPose*>(
      &::_SerializedPose_default_instance_);
}
inline ::SerializedPose* SerializedKeyframe::release_pose() {
  // @@protoc_insertion_point(field_release:SerializedKeyframe.pose)
  
  ::SerializedPose* temp = pose_;
  pose_ = NULL;
  return temp;
}
inline ::SerializedPose* SerializedKeyframe::mutable_pose() {
  
  if (pose_ == NULL) {
    auto* p = CreateMaybeMessage<::SerializedPose>(GetArenaNoVirtual());
    pose_ = p;
  }
  // @@protoc_insertion_point(field_mutable:SerializedKeyframe.pose)
  return pose_;
}
inline void SerializedKeyframe::set_allocated_pose(::SerializedPose* pose) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete pose_;
  }
  if (pose) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      pose = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, pose, submessage_arena);
    }
    
  } else {
    
  }
  pose_ = pose;
  // @@protoc_insertion_point(field_set_allocated:SerializedKeyframe.pose)
}

// .SerializedK kmatrix = 3;
inline bool SerializedKeyframe::has_kmatrix() const {
  return this != internal_default_instance() && kmatrix_ != NULL;
}
inline void SerializedKeyframe::clear_kmatrix() {
  if (GetArenaNoVirtual() == NULL && kmatrix_ != NULL) {
    delete kmatrix_;
  }
  kmatrix_ = NULL;
}
inline const ::SerializedK& SerializedKeyframe::_internal_kmatrix() const {
  return *kmatrix_;
}
inline const ::SerializedK& SerializedKeyframe::kmatrix() const {
  const ::SerializedK* p = kmatrix_;
  // @@protoc_insertion_point(field_get:SerializedKeyframe.kmatrix)
  return p != NULL ? *p : *reinterpret_cast<const ::SerializedK*>(
      &::_SerializedK_default_instance_);
}
inline ::SerializedK* SerializedKeyframe::release_kmatrix() {
  // @@protoc_insertion_point(field_release:SerializedKeyframe.kmatrix)
  
  ::SerializedK* temp = kmatrix_;
  kmatrix_ = NULL;
  return temp;
}
inline ::SerializedK* SerializedKeyframe::mutable_kmatrix() {
  
  if (kmatrix_ == NULL) {
    auto* p = CreateMaybeMessage<::SerializedK>(GetArenaNoVirtual());
    kmatrix_ = p;
  }
  // @@protoc_insertion_point(field_mutable:SerializedKeyframe.kmatrix)
  return kmatrix_;
}
inline void SerializedKeyframe::set_allocated_kmatrix(::SerializedK* kmatrix) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete kmatrix_;
  }
  if (kmatrix) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      kmatrix = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, kmatrix, submessage_arena);
    }
    
  } else {
    
  }
  kmatrix_ = kmatrix;
  // @@protoc_insertion_point(field_set_allocated:SerializedKeyframe.kmatrix)
}

// uint32 kindex = 4;
inline void SerializedKeyframe::clear_kindex() {
  kindex_ = 0u;
}
inline ::google::protobuf::uint32 SerializedKeyframe::kindex() const {
  // @@protoc_insertion_point(field_get:SerializedKeyframe.kindex)
  return kindex_;
}
inline void SerializedKeyframe::set_kindex(::google::protobuf::uint32 value) {
  
  kindex_ = value;
  // @@protoc_insertion_point(field_set:SerializedKeyframe.kindex)
}

// repeated uint32 loopedgesids = 5;
inline int SerializedKeyframe::loopedgesids_size() const {
  return loopedgesids_.size();
}
inline void SerializedKeyframe::clear_loopedgesids() {
  loopedgesids_.Clear();
}
inline ::google::protobuf::uint32 SerializedKeyframe::loopedgesids(int index) const {
  // @@protoc_insertion_point(field_get:SerializedKeyframe.loopedgesids)
  return loopedgesids_.Get(index);
}
inline void SerializedKeyframe::set_loopedgesids(int index, ::google::protobuf::uint32 value) {
  loopedgesids_.Set(index, value);
  // @@protoc_insertion_point(field_set:SerializedKeyframe.loopedgesids)
}
inline void SerializedKeyframe::add_loopedgesids(::google::protobuf::uint32 value) {
  loopedgesids_.Add(value);
  // @@protoc_insertion_point(field_add:SerializedKeyframe.loopedgesids)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
SerializedKeyframe::loopedgesids() const {
  // @@protoc_insertion_point(field_list:SerializedKeyframe.loopedgesids)
  return loopedgesids_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
SerializedKeyframe::mutable_loopedgesids() {
  // @@protoc_insertion_point(field_mutable_list:SerializedKeyframe.loopedgesids)
  return &loopedgesids_;
}

// double timestamp = 6;
inline void SerializedKeyframe::clear_timestamp() {
  timestamp_ = 0;
}
inline double SerializedKeyframe::timestamp() const {
  // @@protoc_insertion_point(field_get:SerializedKeyframe.timestamp)
  return timestamp_;
}
inline void SerializedKeyframe::set_timestamp(double value) {
  
  timestamp_ = value;
  // @@protoc_insertion_point(field_set:SerializedKeyframe.timestamp)
}

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

// SerializedKeyframeArray

// repeated .SerializedKeyframe keyframe = 1;
inline int SerializedKeyframeArray::keyframe_size() const {
  return keyframe_.size();
}
inline void SerializedKeyframeArray::clear_keyframe() {
  keyframe_.Clear();
}
inline ::SerializedKeyframe* SerializedKeyframeArray::mutable_keyframe(int index) {
  // @@protoc_insertion_point(field_mutable:SerializedKeyframeArray.keyframe)
  return keyframe_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::SerializedKeyframe >*
SerializedKeyframeArray::mutable_keyframe() {
  // @@protoc_insertion_point(field_mutable_list:SerializedKeyframeArray.keyframe)
  return &keyframe_;
}
inline const ::SerializedKeyframe& SerializedKeyframeArray::keyframe(int index) const {
  // @@protoc_insertion_point(field_get:SerializedKeyframeArray.keyframe)
  return keyframe_.Get(index);
}
inline ::SerializedKeyframe* SerializedKeyframeArray::add_keyframe() {
  // @@protoc_insertion_point(field_add:SerializedKeyframeArray.keyframe)
  return keyframe_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::SerializedKeyframe >&
SerializedKeyframeArray::keyframe() const {
  // @@protoc_insertion_point(field_list:SerializedKeyframeArray.keyframe)
  return keyframe_;
}

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

// SerializedFeature

// uint32 mappoint_id = 2;
inline void SerializedFeature::clear_mappoint_id() {
  mappoint_id_ = 0u;
}
inline ::google::protobuf::uint32 SerializedFeature::mappoint_id() const {
  // @@protoc_insertion_point(field_get:SerializedFeature.mappoint_id)
  return mappoint_id_;
}
inline void SerializedFeature::set_mappoint_id(::google::protobuf::uint32 value) {
  
  mappoint_id_ = value;
  // @@protoc_insertion_point(field_set:SerializedFeature.mappoint_id)
}

// .SerializedKeypoint keypoint = 3;
inline bool SerializedFeature::has_keypoint() const {
  return this != internal_default_instance() && keypoint_ != NULL;
}
inline void SerializedFeature::clear_keypoint() {
  if (GetArenaNoVirtual() == NULL && keypoint_ != NULL) {
    delete keypoint_;
  }
  keypoint_ = NULL;
}
inline const ::SerializedKeypoint& SerializedFeature::_internal_keypoint() const {
  return *keypoint_;
}
inline const ::SerializedKeypoint& SerializedFeature::keypoint() const {
  const ::SerializedKeypoint* p = keypoint_;
  // @@protoc_insertion_point(field_get:SerializedFeature.keypoint)
  return p != NULL ? *p : *reinterpret_cast<const ::SerializedKeypoint*>(
      &::_SerializedKeypoint_default_instance_);
}
inline ::SerializedKeypoint* SerializedFeature::release_keypoint() {
  // @@protoc_insertion_point(field_release:SerializedFeature.keypoint)
  
  ::SerializedKeypoint* temp = keypoint_;
  keypoint_ = NULL;
  return temp;
}
inline ::SerializedKeypoint* SerializedFeature::mutable_keypoint() {
  
  if (keypoint_ == NULL) {
    auto* p = CreateMaybeMessage<::SerializedKeypoint>(GetArenaNoVirtual());
    keypoint_ = p;
  }
  // @@protoc_insertion_point(field_mutable:SerializedFeature.keypoint)
  return keypoint_;
}
inline void SerializedFeature::set_allocated_keypoint(::SerializedKeypoint* keypoint) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete keypoint_;
  }
  if (keypoint) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      keypoint = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, keypoint, submessage_arena);
    }
    
  } else {
    
  }
  keypoint_ = keypoint;
  // @@protoc_insertion_point(field_set_allocated:SerializedFeature.keypoint)
}

// .SerializedDescriptor briefdescriptor = 4;
inline bool SerializedFeature::has_briefdescriptor() const {
  return this != internal_default_instance() && briefdescriptor_ != NULL;
}
inline void SerializedFeature::clear_briefdescriptor() {
  if (GetArenaNoVirtual() == NULL && briefdescriptor_ != NULL) {
    delete briefdescriptor_;
  }
  briefdescriptor_ = NULL;
}
inline const ::SerializedDescriptor& SerializedFeature::_internal_briefdescriptor() const {
  return *briefdescriptor_;
}
inline const ::SerializedDescriptor& SerializedFeature::briefdescriptor() const {
  const ::SerializedDescriptor* p = briefdescriptor_;
  // @@protoc_insertion_point(field_get:SerializedFeature.briefdescriptor)
  return p != NULL ? *p : *reinterpret_cast<const ::SerializedDescriptor*>(
      &::_SerializedDescriptor_default_instance_);
}
inline ::SerializedDescriptor* SerializedFeature::release_briefdescriptor() {
  // @@protoc_insertion_point(field_release:SerializedFeature.briefdescriptor)
  
  ::SerializedDescriptor* temp = briefdescriptor_;
  briefdescriptor_ = NULL;
  return temp;
}
inline ::SerializedDescriptor* SerializedFeature::mutable_briefdescriptor() {
  
  if (briefdescriptor_ == NULL) {
    auto* p = CreateMaybeMessage<::SerializedDescriptor>(GetArenaNoVirtual());
    briefdescriptor_ = p;
  }
  // @@protoc_insertion_point(field_mutable:SerializedFeature.briefdescriptor)
  return briefdescriptor_;
}
inline void SerializedFeature::set_allocated_briefdescriptor(::SerializedDescriptor* briefdescriptor) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete briefdescriptor_;
  }
  if (briefdescriptor) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      briefdescriptor = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, briefdescriptor, submessage_arena);
    }
    
  } else {
    
  }
  briefdescriptor_ = briefdescriptor;
  // @@protoc_insertion_point(field_set_allocated:SerializedFeature.briefdescriptor)
}

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

// SerializedKeyframeFeatures

// uint32 keyframe_id = 1;
inline void SerializedKeyframeFeatures::clear_keyframe_id() {
  keyframe_id_ = 0u;
}
inline ::google::protobuf::uint32 SerializedKeyframeFeatures::keyframe_id() const {
  // @@protoc_insertion_point(field_get:SerializedKeyframeFeatures.keyframe_id)
  return keyframe_id_;
}
inline void SerializedKeyframeFeatures::set_keyframe_id(::google::protobuf::uint32 value) {
  
  keyframe_id_ = value;
  // @@protoc_insertion_point(field_set:SerializedKeyframeFeatures.keyframe_id)
}

// repeated .SerializedFeature feature = 2;
inline int SerializedKeyframeFeatures::feature_size() const {
  return feature_.size();
}
inline void SerializedKeyframeFeatures::clear_feature() {
  feature_.Clear();
}
inline ::SerializedFeature* SerializedKeyframeFeatures::mutable_feature(int index) {
  // @@protoc_insertion_point(field_mutable:SerializedKeyframeFeatures.feature)
  return feature_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::SerializedFeature >*
SerializedKeyframeFeatures::mutable_feature() {
  // @@protoc_insertion_point(field_mutable_list:SerializedKeyframeFeatures.feature)
  return &feature_;
}
inline const ::SerializedFeature& SerializedKeyframeFeatures::feature(int index) const {
  // @@protoc_insertion_point(field_get:SerializedKeyframeFeatures.feature)
  return feature_.Get(index);
}
inline ::SerializedFeature* SerializedKeyframeFeatures::add_feature() {
  // @@protoc_insertion_point(field_add:SerializedKeyframeFeatures.feature)
  return feature_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::SerializedFeature >&
SerializedKeyframeFeatures::feature() const {
  // @@protoc_insertion_point(field_list:SerializedKeyframeFeatures.feature)
  return feature_;
}

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

// SerializedKeyframeFeaturesArray

// repeated .SerializedKeyframeFeatures feature = 1;
inline int SerializedKeyframeFeaturesArray::feature_size() const {
  return feature_.size();
}
inline void SerializedKeyframeFeaturesArray::clear_feature() {
  feature_.Clear();
}
inline ::SerializedKeyframeFeatures* SerializedKeyframeFeaturesArray::mutable_feature(int index) {
  // @@protoc_insertion_point(field_mutable:SerializedKeyframeFeaturesArray.feature)
  return feature_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::SerializedKeyframeFeatures >*
SerializedKeyframeFeaturesArray::mutable_feature() {
  // @@protoc_insertion_point(field_mutable_list:SerializedKeyframeFeaturesArray.feature)
  return &feature_;
}
inline const ::SerializedKeyframeFeatures& SerializedKeyframeFeaturesArray::feature(int index) const {
  // @@protoc_insertion_point(field_get:SerializedKeyframeFeaturesArray.feature)
  return feature_.Get(index);
}
inline ::SerializedKeyframeFeatures* SerializedKeyframeFeaturesArray::add_feature() {
  // @@protoc_insertion_point(field_add:SerializedKeyframeFeaturesArray.feature)
  return feature_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::SerializedKeyframeFeatures >&
SerializedKeyframeFeaturesArray::feature() const {
  // @@protoc_insertion_point(field_list:SerializedKeyframeFeaturesArray.feature)
  return feature_;
}

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_osmap_2eproto
