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

#ifndef GOOGLE_PROTOBUF_INCLUDED_vector_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_vector_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3020000
#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 3020003 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

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

// Internal implementation detail -- do not use these members.
struct TableStruct_vector_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_vector_2eproto;
namespace Messages {
class DirentNode;
struct DirentNodeDefaultTypeInternal;
extern DirentNodeDefaultTypeInternal _DirentNode_default_instance_;
class Elements;
struct ElementsDefaultTypeInternal;
extern ElementsDefaultTypeInternal _Elements_default_instance_;
class Extrema;
struct ExtremaDefaultTypeInternal;
extern ExtremaDefaultTypeInternal _Extrema_default_instance_;
class File;
struct FileDefaultTypeInternal;
extern FileDefaultTypeInternal _File_default_instance_;
class Record64;
struct Record64DefaultTypeInternal;
extern Record64DefaultTypeInternal _Record64_default_instance_;
class Revision;
struct RevisionDefaultTypeInternal;
extern RevisionDefaultTypeInternal _Revision_default_instance_;
class Rule;
struct RuleDefaultTypeInternal;
extern RuleDefaultTypeInternal _Rule_default_instance_;
class SparseMatrix;
struct SparseMatrixDefaultTypeInternal;
extern SparseMatrixDefaultTypeInternal _SparseMatrix_default_instance_;
class UIndices;
struct UIndicesDefaultTypeInternal;
extern UIndicesDefaultTypeInternal _UIndices_default_instance_;
class Vector32;
struct Vector32DefaultTypeInternal;
extern Vector32DefaultTypeInternal _Vector32_default_instance_;
class Vector64;
struct Vector64DefaultTypeInternal;
extern Vector64DefaultTypeInternal _Vector64_default_instance_;
}  // namespace Messages
PROTOBUF_NAMESPACE_OPEN
template<> ::Messages::DirentNode* Arena::CreateMaybeMessage<::Messages::DirentNode>(Arena*);
template<> ::Messages::Elements* Arena::CreateMaybeMessage<::Messages::Elements>(Arena*);
template<> ::Messages::Extrema* Arena::CreateMaybeMessage<::Messages::Extrema>(Arena*);
template<> ::Messages::File* Arena::CreateMaybeMessage<::Messages::File>(Arena*);
template<> ::Messages::Record64* Arena::CreateMaybeMessage<::Messages::Record64>(Arena*);
template<> ::Messages::Revision* Arena::CreateMaybeMessage<::Messages::Revision>(Arena*);
template<> ::Messages::Rule* Arena::CreateMaybeMessage<::Messages::Rule>(Arena*);
template<> ::Messages::SparseMatrix* Arena::CreateMaybeMessage<::Messages::SparseMatrix>(Arena*);
template<> ::Messages::UIndices* Arena::CreateMaybeMessage<::Messages::UIndices>(Arena*);
template<> ::Messages::Vector32* Arena::CreateMaybeMessage<::Messages::Vector32>(Arena*);
template<> ::Messages::Vector64* Arena::CreateMaybeMessage<::Messages::Vector64>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace Messages {

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

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

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

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

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

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

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

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

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(File* other);

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

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

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

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

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

  enum : int {
    kNameFieldNumber = 1,
    kPayloadFieldNumber = 2,
    kTimeCreatedFieldNumber = 10,
    kTimeModifiedFieldNumber = 11,
    kIsLocalFieldNumber = 3,
    kIsExportedFieldNumber = 4,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // bytes payload = 2;
  void clear_payload();
  const std::string& payload() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_payload(ArgT0&& arg0, ArgT... args);
  std::string* mutable_payload();
  PROTOBUF_NODISCARD std::string* release_payload();
  void set_allocated_payload(std::string* payload);
  private:
  const std::string& _internal_payload() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value);
  std::string* _internal_mutable_payload();
  public:

  // uint64 time_created = 10;
  void clear_time_created();
  uint64_t time_created() const;
  void set_time_created(uint64_t value);
  private:
  uint64_t _internal_time_created() const;
  void _internal_set_time_created(uint64_t value);
  public:

  // uint64 time_modified = 11;
  void clear_time_modified();
  uint64_t time_modified() const;
  void set_time_modified(uint64_t value);
  private:
  uint64_t _internal_time_modified() const;
  void _internal_set_time_modified(uint64_t value);
  public:

  // bool is_local = 3;
  void clear_is_local();
  bool is_local() const;
  void set_is_local(bool value);
  private:
  bool _internal_is_local() const;
  void _internal_set_is_local(bool value);
  public:

  // bool is_exported = 4;
  void clear_is_exported();
  bool is_exported() const;
  void set_is_exported(bool value);
  private:
  bool _internal_is_exported() const;
  void _internal_set_is_exported(bool value);
  public:

  // @@protoc_insertion_point(class_scope:Messages.File)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
  uint64_t time_created_;
  uint64_t time_modified_;
  bool is_local_;
  bool is_exported_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_vector_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DirentNode* other);

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

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

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

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

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

  enum : int {
    kFilesFieldNumber = 2,
    kSubdirsFieldNumber = 3,
    kDirnameFieldNumber = 1,
  };
  // repeated string files = 2;
  int files_size() const;
  private:
  int _internal_files_size() const;
  public:
  void clear_files();
  const std::string& files(int index) const;
  std::string* mutable_files(int index);
  void set_files(int index, const std::string& value);
  void set_files(int index, std::string&& value);
  void set_files(int index, const char* value);
  void set_files(int index, const char* value, size_t size);
  std::string* add_files();
  void add_files(const std::string& value);
  void add_files(std::string&& value);
  void add_files(const char* value);
  void add_files(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& files() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_files();
  private:
  const std::string& _internal_files(int index) const;
  std::string* _internal_add_files();
  public:

  // repeated .Messages.DirentNode subdirs = 3;
  int subdirs_size() const;
  private:
  int _internal_subdirs_size() const;
  public:
  void clear_subdirs();
  ::Messages::DirentNode* mutable_subdirs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::DirentNode >*
      mutable_subdirs();
  private:
  const ::Messages::DirentNode& _internal_subdirs(int index) const;
  ::Messages::DirentNode* _internal_add_subdirs();
  public:
  const ::Messages::DirentNode& subdirs(int index) const;
  ::Messages::DirentNode* add_subdirs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::DirentNode >&
      subdirs() const;

  // string dirname = 1;
  void clear_dirname();
  const std::string& dirname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_dirname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_dirname();
  PROTOBUF_NODISCARD std::string* release_dirname();
  void set_allocated_dirname(std::string* dirname);
  private:
  const std::string& _internal_dirname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dirname(const std::string& value);
  std::string* _internal_mutable_dirname();
  public:

  // @@protoc_insertion_point(class_scope:Messages.DirentNode)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> files_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::DirentNode > subdirs_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dirname_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_vector_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Revision* other);

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

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

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

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

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

  enum : int {
    kMajorRevFieldNumber = 1,
    kMinorRevFieldNumber = 2,
  };
  // uint64 major_rev = 1;
  void clear_major_rev();
  uint64_t major_rev() const;
  void set_major_rev(uint64_t value);
  private:
  uint64_t _internal_major_rev() const;
  void _internal_set_major_rev(uint64_t value);
  public:

  // uint64 minor_rev = 2;
  void clear_minor_rev();
  uint64_t minor_rev() const;
  void set_minor_rev(uint64_t value);
  private:
  uint64_t _internal_minor_rev() const;
  void _internal_set_minor_rev(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:Messages.Revision)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  uint64_t major_rev_;
  uint64_t minor_rev_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_vector_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Extrema* other);

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

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

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

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

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

  enum : int {
    kMinFieldNumber = 2,
    kMaxFieldNumber = 3,
    kDimsFieldNumber = 1,
    kIsSetFieldNumber = 4,
  };
  // repeated double min = 2 [packed = true];
  int min_size() const;
  private:
  int _internal_min_size() const;
  public:
  void clear_min();
  private:
  double _internal_min(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_min() const;
  void _internal_add_min(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_min();
  public:
  double min(int index) const;
  void set_min(int index, double value);
  void add_min(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      min() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_min();

  // repeated double max = 3 [packed = true];
  int max_size() const;
  private:
  int _internal_max_size() const;
  public:
  void clear_max();
  private:
  double _internal_max(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_max() const;
  void _internal_add_max(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_max();
  public:
  double max(int index) const;
  void set_max(int index, double value);
  void add_max(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      max() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_max();

  // uint32 dims = 1;
  void clear_dims();
  uint32_t dims() const;
  void set_dims(uint32_t value);
  private:
  uint32_t _internal_dims() const;
  void _internal_set_dims(uint32_t value);
  public:

  // bool is_set = 4;
  void clear_is_set();
  bool is_set() const;
  void set_is_set(bool value);
  private:
  bool _internal_is_set() const;
  void _internal_set_is_set(bool value);
  public:

  // @@protoc_insertion_point(class_scope:Messages.Extrema)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > min_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > max_;
  uint32_t dims_;
  bool is_set_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_vector_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Vector32* other);

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

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

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

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

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

  enum : int {
    kValuesFieldNumber = 10,
    kSizeHintFieldNumber = 11,
    kNameFieldNumber = 1,
    kUnitsFieldNumber = 5,
    kCommentFieldNumber = 6,
    kRevisionFieldNumber = 4,
    kComponentsFieldNumber = 2,
    kInterleavedFieldNumber = 3,
    kOffsetFieldNumber = 9,
  };
  // repeated float values = 10 [packed = true];
  int values_size() const;
  private:
  int _internal_values_size() const;
  public:
  void clear_values();
  private:
  float _internal_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      _internal_values() const;
  void _internal_add_values(float value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      _internal_mutable_values();
  public:
  float values(int index) const;
  void set_values(int index, float value);
  void add_values(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_values();

  // repeated uint32 size_hint = 11 [packed = true];
  int size_hint_size() const;
  private:
  int _internal_size_hint_size() const;
  public:
  void clear_size_hint();
  private:
  uint32_t _internal_size_hint(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_size_hint() const;
  void _internal_add_size_hint(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_size_hint();
  public:
  uint32_t size_hint(int index) const;
  void set_size_hint(int index, uint32_t value);
  void add_size_hint(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      size_hint() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_size_hint();

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

  // string units = 5;
  void clear_units();
  const std::string& units() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_units(ArgT0&& arg0, ArgT... args);
  std::string* mutable_units();
  PROTOBUF_NODISCARD std::string* release_units();
  void set_allocated_units(std::string* units);
  private:
  const std::string& _internal_units() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_units(const std::string& value);
  std::string* _internal_mutable_units();
  public:

  // string comment = 6;
  void clear_comment();
  const std::string& comment() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_comment(ArgT0&& arg0, ArgT... args);
  std::string* mutable_comment();
  PROTOBUF_NODISCARD std::string* release_comment();
  void set_allocated_comment(std::string* comment);
  private:
  const std::string& _internal_comment() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_comment(const std::string& value);
  std::string* _internal_mutable_comment();
  public:

  // .Messages.Revision revision = 4;
  bool has_revision() const;
  private:
  bool _internal_has_revision() const;
  public:
  void clear_revision();
  const ::Messages::Revision& revision() const;
  PROTOBUF_NODISCARD ::Messages::Revision* release_revision();
  ::Messages::Revision* mutable_revision();
  void set_allocated_revision(::Messages::Revision* revision);
  private:
  const ::Messages::Revision& _internal_revision() const;
  ::Messages::Revision* _internal_mutable_revision();
  public:
  void unsafe_arena_set_allocated_revision(
      ::Messages::Revision* revision);
  ::Messages::Revision* unsafe_arena_release_revision();

  // uint32 components = 2;
  void clear_components();
  uint32_t components() const;
  void set_components(uint32_t value);
  private:
  uint32_t _internal_components() const;
  void _internal_set_components(uint32_t value);
  public:

  // bool interleaved = 3;
  void clear_interleaved();
  bool interleaved() const;
  void set_interleaved(bool value);
  private:
  bool _internal_interleaved() const;
  void _internal_set_interleaved(bool value);
  public:

  // uint64 offset = 9;
  void clear_offset();
  uint64_t offset() const;
  void set_offset(uint64_t value);
  private:
  uint64_t _internal_offset() const;
  void _internal_set_offset(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:Messages.Vector32)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > values_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > size_hint_;
  mutable std::atomic<int> _size_hint_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr units_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comment_;
  ::Messages::Revision* revision_;
  uint32_t components_;
  bool interleaved_;
  uint64_t offset_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_vector_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Vector64* other);

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

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

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

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

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

  enum : int {
    kValuesFieldNumber = 10,
    kSizeHintFieldNumber = 11,
    kNameFieldNumber = 1,
    kUnitsFieldNumber = 5,
    kCommentFieldNumber = 6,
    kRevisionFieldNumber = 4,
    kComponentsFieldNumber = 2,
    kInterleavedFieldNumber = 3,
    kOffsetFieldNumber = 9,
  };
  // repeated double values = 10 [packed = true];
  int values_size() const;
  private:
  int _internal_values_size() const;
  public:
  void clear_values();
  private:
  double _internal_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_values() const;
  void _internal_add_values(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_values();
  public:
  double values(int index) const;
  void set_values(int index, double value);
  void add_values(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_values();

  // repeated uint32 size_hint = 11 [packed = true];
  int size_hint_size() const;
  private:
  int _internal_size_hint_size() const;
  public:
  void clear_size_hint();
  private:
  uint32_t _internal_size_hint(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_size_hint() const;
  void _internal_add_size_hint(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_size_hint();
  public:
  uint32_t size_hint(int index) const;
  void set_size_hint(int index, uint32_t value);
  void add_size_hint(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      size_hint() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_size_hint();

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

  // string units = 5;
  void clear_units();
  const std::string& units() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_units(ArgT0&& arg0, ArgT... args);
  std::string* mutable_units();
  PROTOBUF_NODISCARD std::string* release_units();
  void set_allocated_units(std::string* units);
  private:
  const std::string& _internal_units() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_units(const std::string& value);
  std::string* _internal_mutable_units();
  public:

  // string comment = 6;
  void clear_comment();
  const std::string& comment() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_comment(ArgT0&& arg0, ArgT... args);
  std::string* mutable_comment();
  PROTOBUF_NODISCARD std::string* release_comment();
  void set_allocated_comment(std::string* comment);
  private:
  const std::string& _internal_comment() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_comment(const std::string& value);
  std::string* _internal_mutable_comment();
  public:

  // .Messages.Revision revision = 4;
  bool has_revision() const;
  private:
  bool _internal_has_revision() const;
  public:
  void clear_revision();
  const ::Messages::Revision& revision() const;
  PROTOBUF_NODISCARD ::Messages::Revision* release_revision();
  ::Messages::Revision* mutable_revision();
  void set_allocated_revision(::Messages::Revision* revision);
  private:
  const ::Messages::Revision& _internal_revision() const;
  ::Messages::Revision* _internal_mutable_revision();
  public:
  void unsafe_arena_set_allocated_revision(
      ::Messages::Revision* revision);
  ::Messages::Revision* unsafe_arena_release_revision();

  // uint32 components = 2;
  void clear_components();
  uint32_t components() const;
  void set_components(uint32_t value);
  private:
  uint32_t _internal_components() const;
  void _internal_set_components(uint32_t value);
  public:

  // bool interleaved = 3;
  void clear_interleaved();
  bool interleaved() const;
  void set_interleaved(bool value);
  private:
  bool _internal_interleaved() const;
  void _internal_set_interleaved(bool value);
  public:

  // uint64 offset = 9;
  void clear_offset();
  uint64_t offset() const;
  void set_offset(uint64_t value);
  private:
  uint64_t _internal_offset() const;
  void _internal_set_offset(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:Messages.Vector64)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > values_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > size_hint_;
  mutable std::atomic<int> _size_hint_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr units_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comment_;
  ::Messages::Revision* revision_;
  uint32_t components_;
  bool interleaved_;
  uint64_t offset_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_vector_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SparseMatrix* other);

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

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

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

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

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

  enum : int {
    kSizeHintFieldNumber = 2,
    kIndicesFieldNumber = 3,
    kValuesFieldNumber = 4,
    kNameFieldNumber = 1,
    kBoundsFieldNumber = 5,
  };
  // repeated uint32 size_hint = 2 [packed = true];
  int size_hint_size() const;
  private:
  int _internal_size_hint_size() const;
  public:
  void clear_size_hint();
  private:
  uint32_t _internal_size_hint(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_size_hint() const;
  void _internal_add_size_hint(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_size_hint();
  public:
  uint32_t size_hint(int index) const;
  void set_size_hint(int index, uint32_t value);
  void add_size_hint(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      size_hint() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_size_hint();

  // repeated uint32 indices = 3 [packed = true];
  int indices_size() const;
  private:
  int _internal_indices_size() const;
  public:
  void clear_indices();
  private:
  uint32_t _internal_indices(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_indices() const;
  void _internal_add_indices(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_indices();
  public:
  uint32_t indices(int index) const;
  void set_indices(int index, uint32_t value);
  void add_indices(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      indices() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_indices();

  // repeated double values = 4 [packed = true];
  int values_size() const;
  private:
  int _internal_values_size() const;
  public:
  void clear_values();
  private:
  double _internal_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_values() const;
  void _internal_add_values(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_values();
  public:
  double values(int index) const;
  void set_values(int index, double value);
  void add_values(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_values();

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

  // .Messages.Extrema bounds = 5;
  bool has_bounds() const;
  private:
  bool _internal_has_bounds() const;
  public:
  void clear_bounds();
  const ::Messages::Extrema& bounds() const;
  PROTOBUF_NODISCARD ::Messages::Extrema* release_bounds();
  ::Messages::Extrema* mutable_bounds();
  void set_allocated_bounds(::Messages::Extrema* bounds);
  private:
  const ::Messages::Extrema& _internal_bounds() const;
  ::Messages::Extrema* _internal_mutable_bounds();
  public:
  void unsafe_arena_set_allocated_bounds(
      ::Messages::Extrema* bounds);
  ::Messages::Extrema* unsafe_arena_release_bounds();

  // @@protoc_insertion_point(class_scope:Messages.SparseMatrix)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > size_hint_;
  mutable std::atomic<int> _size_hint_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > indices_;
  mutable std::atomic<int> _indices_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > values_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::Messages::Extrema* bounds_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_vector_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Rule* other);

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

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

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

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

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

  enum : int {
    kAlgorithmsFieldNumber = 4,
    kFailedNodesFieldNumber = 5,
    kFailedValuesFieldNumber = 6,
    kPkFieldNumber = 1,
    kValueFieldNumber = 3,
    kOpFieldNumber = 2,
  };
  // repeated string algorithms = 4;
  int algorithms_size() const;
  private:
  int _internal_algorithms_size() const;
  public:
  void clear_algorithms();
  const std::string& algorithms(int index) const;
  std::string* mutable_algorithms(int index);
  void set_algorithms(int index, const std::string& value);
  void set_algorithms(int index, std::string&& value);
  void set_algorithms(int index, const char* value);
  void set_algorithms(int index, const char* value, size_t size);
  std::string* add_algorithms();
  void add_algorithms(const std::string& value);
  void add_algorithms(std::string&& value);
  void add_algorithms(const char* value);
  void add_algorithms(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& algorithms() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_algorithms();
  private:
  const std::string& _internal_algorithms(int index) const;
  std::string* _internal_add_algorithms();
  public:

  // repeated uint32 failed_nodes = 5 [packed = true];
  int failed_nodes_size() const;
  private:
  int _internal_failed_nodes_size() const;
  public:
  void clear_failed_nodes();
  private:
  uint32_t _internal_failed_nodes(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_failed_nodes() const;
  void _internal_add_failed_nodes(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_failed_nodes();
  public:
  uint32_t failed_nodes(int index) const;
  void set_failed_nodes(int index, uint32_t value);
  void add_failed_nodes(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      failed_nodes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_failed_nodes();

  // repeated double failed_values = 6 [packed = true];
  int failed_values_size() const;
  private:
  int _internal_failed_values_size() const;
  public:
  void clear_failed_values();
  private:
  double _internal_failed_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_failed_values() const;
  void _internal_add_failed_values(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_failed_values();
  public:
  double failed_values(int index) const;
  void set_failed_values(int index, double value);
  void add_failed_values(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      failed_values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_failed_values();

  // string pk = 1;
  void clear_pk();
  const std::string& pk() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_pk(ArgT0&& arg0, ArgT... args);
  std::string* mutable_pk();
  PROTOBUF_NODISCARD std::string* release_pk();
  void set_allocated_pk(std::string* pk);
  private:
  const std::string& _internal_pk() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pk(const std::string& value);
  std::string* _internal_mutable_pk();
  public:

  // double value = 3;
  void clear_value();
  double value() const;
  void set_value(double value);
  private:
  double _internal_value() const;
  void _internal_set_value(double value);
  public:

  // uint32 op = 2;
  void clear_op();
  uint32_t op() const;
  void set_op(uint32_t value);
  private:
  uint32_t _internal_op() const;
  void _internal_set_op(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:Messages.Rule)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> algorithms_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > failed_nodes_;
  mutable std::atomic<int> _failed_nodes_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > failed_values_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pk_;
  double value_;
  uint32_t op_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_vector_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Record64* other);

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

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

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

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

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

  enum : int {
    kRequirementsFieldNumber = 9,
    kDataFieldNumber = 10,
    kMatrixFieldNumber = 11,
    kNameFieldNumber = 1,
    kOwnerFieldNumber = 2,
    kRevisionFieldNumber = 3,
    kLengthUnitsFieldNumber = 8,
  };
  // repeated .Messages.Rule requirements = 9;
  int requirements_size() const;
  private:
  int _internal_requirements_size() const;
  public:
  void clear_requirements();
  ::Messages::Rule* mutable_requirements(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Rule >*
      mutable_requirements();
  private:
  const ::Messages::Rule& _internal_requirements(int index) const;
  ::Messages::Rule* _internal_add_requirements();
  public:
  const ::Messages::Rule& requirements(int index) const;
  ::Messages::Rule* add_requirements();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Rule >&
      requirements() const;

  // repeated .Messages.Vector64 data = 10;
  int data_size() const;
  private:
  int _internal_data_size() const;
  public:
  void clear_data();
  ::Messages::Vector64* mutable_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Vector64 >*
      mutable_data();
  private:
  const ::Messages::Vector64& _internal_data(int index) const;
  ::Messages::Vector64* _internal_add_data();
  public:
  const ::Messages::Vector64& data(int index) const;
  ::Messages::Vector64* add_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Vector64 >&
      data() const;

  // repeated .Messages.SparseMatrix matrix = 11;
  int matrix_size() const;
  private:
  int _internal_matrix_size() const;
  public:
  void clear_matrix();
  ::Messages::SparseMatrix* mutable_matrix(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::SparseMatrix >*
      mutable_matrix();
  private:
  const ::Messages::SparseMatrix& _internal_matrix(int index) const;
  ::Messages::SparseMatrix* _internal_add_matrix();
  public:
  const ::Messages::SparseMatrix& matrix(int index) const;
  ::Messages::SparseMatrix* add_matrix();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::SparseMatrix >&
      matrix() const;

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

  // string owner = 2;
  void clear_owner();
  const std::string& owner() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_owner(ArgT0&& arg0, ArgT... args);
  std::string* mutable_owner();
  PROTOBUF_NODISCARD std::string* release_owner();
  void set_allocated_owner(std::string* owner);
  private:
  const std::string& _internal_owner() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_owner(const std::string& value);
  std::string* _internal_mutable_owner();
  public:

  // .Messages.Revision revision = 3;
  bool has_revision() const;
  private:
  bool _internal_has_revision() const;
  public:
  void clear_revision();
  const ::Messages::Revision& revision() const;
  PROTOBUF_NODISCARD ::Messages::Revision* release_revision();
  ::Messages::Revision* mutable_revision();
  void set_allocated_revision(::Messages::Revision* revision);
  private:
  const ::Messages::Revision& _internal_revision() const;
  ::Messages::Revision* _internal_mutable_revision();
  public:
  void unsafe_arena_set_allocated_revision(
      ::Messages::Revision* revision);
  ::Messages::Revision* unsafe_arena_release_revision();

  // uint32 length_units = 8;
  void clear_length_units();
  uint32_t length_units() const;
  void set_length_units(uint32_t value);
  private:
  uint32_t _internal_length_units() const;
  void _internal_set_length_units(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:Messages.Record64)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Rule > requirements_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Vector64 > data_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::SparseMatrix > matrix_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr owner_;
  ::Messages::Revision* revision_;
  uint32_t length_units_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_vector_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(UIndices* other);

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

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

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

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

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

  enum : int {
    kValuesFieldNumber = 10,
    kNameFieldNumber = 1,
    kRevisionFieldNumber = 4,
    kComponentsFieldNumber = 2,
    kInterleavedFieldNumber = 3,
    kOffsetFieldNumber = 9,
  };
  // repeated uint32 values = 10 [packed = true];
  int values_size() const;
  private:
  int _internal_values_size() const;
  public:
  void clear_values();
  private:
  uint32_t _internal_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_values() const;
  void _internal_add_values(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_values();
  public:
  uint32_t values(int index) const;
  void set_values(int index, uint32_t value);
  void add_values(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_values();

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

  // .Messages.Revision revision = 4;
  bool has_revision() const;
  private:
  bool _internal_has_revision() const;
  public:
  void clear_revision();
  const ::Messages::Revision& revision() const;
  PROTOBUF_NODISCARD ::Messages::Revision* release_revision();
  ::Messages::Revision* mutable_revision();
  void set_allocated_revision(::Messages::Revision* revision);
  private:
  const ::Messages::Revision& _internal_revision() const;
  ::Messages::Revision* _internal_mutable_revision();
  public:
  void unsafe_arena_set_allocated_revision(
      ::Messages::Revision* revision);
  ::Messages::Revision* unsafe_arena_release_revision();

  // uint32 components = 2;
  void clear_components();
  uint32_t components() const;
  void set_components(uint32_t value);
  private:
  uint32_t _internal_components() const;
  void _internal_set_components(uint32_t value);
  public:

  // bool interleaved = 3;
  void clear_interleaved();
  bool interleaved() const;
  void set_interleaved(bool value);
  private:
  bool _internal_interleaved() const;
  void _internal_set_interleaved(bool value);
  public:

  // uint64 offset = 9;
  void clear_offset();
  uint64_t offset() const;
  void set_offset(uint64_t value);
  private:
  uint64_t _internal_offset() const;
  void _internal_set_offset(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:Messages.UIndices)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > values_;
  mutable std::atomic<int> _values_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::Messages::Revision* revision_;
  uint32_t components_;
  bool interleaved_;
  uint64_t offset_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_vector_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Elements* other);

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

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

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

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

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

  enum : int {
    kElementIndicesFieldNumber = 1,
    kElementTypesFieldNumber = 2,
    kElementIdsFieldNumber = 3,
    kNodeIndicesFieldNumber = 4,
    kElementCentersFieldNumber = 10,
    kElementMeasuresFieldNumber = 11,
  };
  // repeated uint32 element_indices = 1 [packed = true];
  int element_indices_size() const;
  private:
  int _internal_element_indices_size() const;
  public:
  void clear_element_indices();
  private:
  uint32_t _internal_element_indices(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_element_indices() const;
  void _internal_add_element_indices(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_element_indices();
  public:
  uint32_t element_indices(int index) const;
  void set_element_indices(int index, uint32_t value);
  void add_element_indices(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      element_indices() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_element_indices();

  // repeated uint32 element_types = 2 [packed = true];
  int element_types_size() const;
  private:
  int _internal_element_types_size() const;
  public:
  void clear_element_types();
  private:
  uint32_t _internal_element_types(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_element_types() const;
  void _internal_add_element_types(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_element_types();
  public:
  uint32_t element_types(int index) const;
  void set_element_types(int index, uint32_t value);
  void add_element_types(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      element_types() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_element_types();

  // repeated int32 element_ids = 3 [packed = true];
  int element_ids_size() const;
  private:
  int _internal_element_ids_size() const;
  public:
  void clear_element_ids();
  private:
  int32_t _internal_element_ids(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_element_ids() const;
  void _internal_add_element_ids(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_element_ids();
  public:
  int32_t element_ids(int index) const;
  void set_element_ids(int index, int32_t value);
  void add_element_ids(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      element_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_element_ids();

  // repeated uint32 node_indices = 4 [packed = true];
  int node_indices_size() const;
  private:
  int _internal_node_indices_size() const;
  public:
  void clear_node_indices();
  private:
  uint32_t _internal_node_indices(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_node_indices() const;
  void _internal_add_node_indices(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_node_indices();
  public:
  uint32_t node_indices(int index) const;
  void set_node_indices(int index, uint32_t value);
  void add_node_indices(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      node_indices() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_node_indices();

  // repeated double element_centers = 10 [packed = true];
  int element_centers_size() const;
  private:
  int _internal_element_centers_size() const;
  public:
  void clear_element_centers();
  private:
  double _internal_element_centers(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_element_centers() const;
  void _internal_add_element_centers(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_element_centers();
  public:
  double element_centers(int index) const;
  void set_element_centers(int index, double value);
  void add_element_centers(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      element_centers() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_element_centers();

  // repeated double element_measures = 11 [packed = true];
  int element_measures_size() const;
  private:
  int _internal_element_measures_size() const;
  public:
  void clear_element_measures();
  private:
  double _internal_element_measures(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_element_measures() const;
  void _internal_add_element_measures(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_element_measures();
  public:
  double element_measures(int index) const;
  void set_element_measures(int index, double value);
  void add_element_measures(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      element_measures() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_element_measures();

  // @@protoc_insertion_point(class_scope:Messages.Elements)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > element_indices_;
  mutable std::atomic<int> _element_indices_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > element_types_;
  mutable std::atomic<int> _element_types_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > element_ids_;
  mutable std::atomic<int> _element_ids_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > node_indices_;
  mutable std::atomic<int> _node_indices_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > element_centers_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > element_measures_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_vector_2eproto;
};
// ===================================================================


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

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

// string name = 1;
inline void File::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& File::name() const {
  // @@protoc_insertion_point(field_get:Messages.File.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void File::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.File.name)
}
inline std::string* File::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:Messages.File.name)
  return _s;
}
inline const std::string& File::_internal_name() const {
  return name_.Get();
}
inline void File::_internal_set_name(const std::string& value) {
  
  name_.Set(value, GetArenaForAllocation());
}
inline std::string* File::_internal_mutable_name() {
  
  return name_.Mutable(GetArenaForAllocation());
}
inline std::string* File::release_name() {
  // @@protoc_insertion_point(field_release:Messages.File.name)
  return name_.Release();
}
inline void File::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault()) {
    name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.File.name)
}

// bytes payload = 2;
inline void File::clear_payload() {
  payload_.ClearToEmpty();
}
inline const std::string& File::payload() const {
  // @@protoc_insertion_point(field_get:Messages.File.payload)
  return _internal_payload();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void File::set_payload(ArgT0&& arg0, ArgT... args) {
 
 payload_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.File.payload)
}
inline std::string* File::mutable_payload() {
  std::string* _s = _internal_mutable_payload();
  // @@protoc_insertion_point(field_mutable:Messages.File.payload)
  return _s;
}
inline const std::string& File::_internal_payload() const {
  return payload_.Get();
}
inline void File::_internal_set_payload(const std::string& value) {
  
  payload_.Set(value, GetArenaForAllocation());
}
inline std::string* File::_internal_mutable_payload() {
  
  return payload_.Mutable(GetArenaForAllocation());
}
inline std::string* File::release_payload() {
  // @@protoc_insertion_point(field_release:Messages.File.payload)
  return payload_.Release();
}
inline void File::set_allocated_payload(std::string* payload) {
  if (payload != nullptr) {
    
  } else {
    
  }
  payload_.SetAllocated(payload, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (payload_.IsDefault()) {
    payload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.File.payload)
}

// bool is_local = 3;
inline void File::clear_is_local() {
  is_local_ = false;
}
inline bool File::_internal_is_local() const {
  return is_local_;
}
inline bool File::is_local() const {
  // @@protoc_insertion_point(field_get:Messages.File.is_local)
  return _internal_is_local();
}
inline void File::_internal_set_is_local(bool value) {
  
  is_local_ = value;
}
inline void File::set_is_local(bool value) {
  _internal_set_is_local(value);
  // @@protoc_insertion_point(field_set:Messages.File.is_local)
}

// bool is_exported = 4;
inline void File::clear_is_exported() {
  is_exported_ = false;
}
inline bool File::_internal_is_exported() const {
  return is_exported_;
}
inline bool File::is_exported() const {
  // @@protoc_insertion_point(field_get:Messages.File.is_exported)
  return _internal_is_exported();
}
inline void File::_internal_set_is_exported(bool value) {
  
  is_exported_ = value;
}
inline void File::set_is_exported(bool value) {
  _internal_set_is_exported(value);
  // @@protoc_insertion_point(field_set:Messages.File.is_exported)
}

// uint64 time_created = 10;
inline void File::clear_time_created() {
  time_created_ = uint64_t{0u};
}
inline uint64_t File::_internal_time_created() const {
  return time_created_;
}
inline uint64_t File::time_created() const {
  // @@protoc_insertion_point(field_get:Messages.File.time_created)
  return _internal_time_created();
}
inline void File::_internal_set_time_created(uint64_t value) {
  
  time_created_ = value;
}
inline void File::set_time_created(uint64_t value) {
  _internal_set_time_created(value);
  // @@protoc_insertion_point(field_set:Messages.File.time_created)
}

// uint64 time_modified = 11;
inline void File::clear_time_modified() {
  time_modified_ = uint64_t{0u};
}
inline uint64_t File::_internal_time_modified() const {
  return time_modified_;
}
inline uint64_t File::time_modified() const {
  // @@protoc_insertion_point(field_get:Messages.File.time_modified)
  return _internal_time_modified();
}
inline void File::_internal_set_time_modified(uint64_t value) {
  
  time_modified_ = value;
}
inline void File::set_time_modified(uint64_t value) {
  _internal_set_time_modified(value);
  // @@protoc_insertion_point(field_set:Messages.File.time_modified)
}

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

// DirentNode

// string dirname = 1;
inline void DirentNode::clear_dirname() {
  dirname_.ClearToEmpty();
}
inline const std::string& DirentNode::dirname() const {
  // @@protoc_insertion_point(field_get:Messages.DirentNode.dirname)
  return _internal_dirname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DirentNode::set_dirname(ArgT0&& arg0, ArgT... args) {
 
 dirname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.DirentNode.dirname)
}
inline std::string* DirentNode::mutable_dirname() {
  std::string* _s = _internal_mutable_dirname();
  // @@protoc_insertion_point(field_mutable:Messages.DirentNode.dirname)
  return _s;
}
inline const std::string& DirentNode::_internal_dirname() const {
  return dirname_.Get();
}
inline void DirentNode::_internal_set_dirname(const std::string& value) {
  
  dirname_.Set(value, GetArenaForAllocation());
}
inline std::string* DirentNode::_internal_mutable_dirname() {
  
  return dirname_.Mutable(GetArenaForAllocation());
}
inline std::string* DirentNode::release_dirname() {
  // @@protoc_insertion_point(field_release:Messages.DirentNode.dirname)
  return dirname_.Release();
}
inline void DirentNode::set_allocated_dirname(std::string* dirname) {
  if (dirname != nullptr) {
    
  } else {
    
  }
  dirname_.SetAllocated(dirname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (dirname_.IsDefault()) {
    dirname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.DirentNode.dirname)
}

// repeated string files = 2;
inline int DirentNode::_internal_files_size() const {
  return files_.size();
}
inline int DirentNode::files_size() const {
  return _internal_files_size();
}
inline void DirentNode::clear_files() {
  files_.Clear();
}
inline std::string* DirentNode::add_files() {
  std::string* _s = _internal_add_files();
  // @@protoc_insertion_point(field_add_mutable:Messages.DirentNode.files)
  return _s;
}
inline const std::string& DirentNode::_internal_files(int index) const {
  return files_.Get(index);
}
inline const std::string& DirentNode::files(int index) const {
  // @@protoc_insertion_point(field_get:Messages.DirentNode.files)
  return _internal_files(index);
}
inline std::string* DirentNode::mutable_files(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.DirentNode.files)
  return files_.Mutable(index);
}
inline void DirentNode::set_files(int index, const std::string& value) {
  files_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.DirentNode.files)
}
inline void DirentNode::set_files(int index, std::string&& value) {
  files_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.DirentNode.files)
}
inline void DirentNode::set_files(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  files_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.DirentNode.files)
}
inline void DirentNode::set_files(int index, const char* value, size_t size) {
  files_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.DirentNode.files)
}
inline std::string* DirentNode::_internal_add_files() {
  return files_.Add();
}
inline void DirentNode::add_files(const std::string& value) {
  files_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.DirentNode.files)
}
inline void DirentNode::add_files(std::string&& value) {
  files_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.DirentNode.files)
}
inline void DirentNode::add_files(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  files_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.DirentNode.files)
}
inline void DirentNode::add_files(const char* value, size_t size) {
  files_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.DirentNode.files)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
DirentNode::files() const {
  // @@protoc_insertion_point(field_list:Messages.DirentNode.files)
  return files_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
DirentNode::mutable_files() {
  // @@protoc_insertion_point(field_mutable_list:Messages.DirentNode.files)
  return &files_;
}

// repeated .Messages.DirentNode subdirs = 3;
inline int DirentNode::_internal_subdirs_size() const {
  return subdirs_.size();
}
inline int DirentNode::subdirs_size() const {
  return _internal_subdirs_size();
}
inline void DirentNode::clear_subdirs() {
  subdirs_.Clear();
}
inline ::Messages::DirentNode* DirentNode::mutable_subdirs(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.DirentNode.subdirs)
  return subdirs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::DirentNode >*
DirentNode::mutable_subdirs() {
  // @@protoc_insertion_point(field_mutable_list:Messages.DirentNode.subdirs)
  return &subdirs_;
}
inline const ::Messages::DirentNode& DirentNode::_internal_subdirs(int index) const {
  return subdirs_.Get(index);
}
inline const ::Messages::DirentNode& DirentNode::subdirs(int index) const {
  // @@protoc_insertion_point(field_get:Messages.DirentNode.subdirs)
  return _internal_subdirs(index);
}
inline ::Messages::DirentNode* DirentNode::_internal_add_subdirs() {
  return subdirs_.Add();
}
inline ::Messages::DirentNode* DirentNode::add_subdirs() {
  ::Messages::DirentNode* _add = _internal_add_subdirs();
  // @@protoc_insertion_point(field_add:Messages.DirentNode.subdirs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::DirentNode >&
DirentNode::subdirs() const {
  // @@protoc_insertion_point(field_list:Messages.DirentNode.subdirs)
  return subdirs_;
}

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

// Revision

// uint64 major_rev = 1;
inline void Revision::clear_major_rev() {
  major_rev_ = uint64_t{0u};
}
inline uint64_t Revision::_internal_major_rev() const {
  return major_rev_;
}
inline uint64_t Revision::major_rev() const {
  // @@protoc_insertion_point(field_get:Messages.Revision.major_rev)
  return _internal_major_rev();
}
inline void Revision::_internal_set_major_rev(uint64_t value) {
  
  major_rev_ = value;
}
inline void Revision::set_major_rev(uint64_t value) {
  _internal_set_major_rev(value);
  // @@protoc_insertion_point(field_set:Messages.Revision.major_rev)
}

// uint64 minor_rev = 2;
inline void Revision::clear_minor_rev() {
  minor_rev_ = uint64_t{0u};
}
inline uint64_t Revision::_internal_minor_rev() const {
  return minor_rev_;
}
inline uint64_t Revision::minor_rev() const {
  // @@protoc_insertion_point(field_get:Messages.Revision.minor_rev)
  return _internal_minor_rev();
}
inline void Revision::_internal_set_minor_rev(uint64_t value) {
  
  minor_rev_ = value;
}
inline void Revision::set_minor_rev(uint64_t value) {
  _internal_set_minor_rev(value);
  // @@protoc_insertion_point(field_set:Messages.Revision.minor_rev)
}

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

// Extrema

// uint32 dims = 1;
inline void Extrema::clear_dims() {
  dims_ = 0u;
}
inline uint32_t Extrema::_internal_dims() const {
  return dims_;
}
inline uint32_t Extrema::dims() const {
  // @@protoc_insertion_point(field_get:Messages.Extrema.dims)
  return _internal_dims();
}
inline void Extrema::_internal_set_dims(uint32_t value) {
  
  dims_ = value;
}
inline void Extrema::set_dims(uint32_t value) {
  _internal_set_dims(value);
  // @@protoc_insertion_point(field_set:Messages.Extrema.dims)
}

// repeated double min = 2 [packed = true];
inline int Extrema::_internal_min_size() const {
  return min_.size();
}
inline int Extrema::min_size() const {
  return _internal_min_size();
}
inline void Extrema::clear_min() {
  min_.Clear();
}
inline double Extrema::_internal_min(int index) const {
  return min_.Get(index);
}
inline double Extrema::min(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Extrema.min)
  return _internal_min(index);
}
inline void Extrema::set_min(int index, double value) {
  min_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Extrema.min)
}
inline void Extrema::_internal_add_min(double value) {
  min_.Add(value);
}
inline void Extrema::add_min(double value) {
  _internal_add_min(value);
  // @@protoc_insertion_point(field_add:Messages.Extrema.min)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Extrema::_internal_min() const {
  return min_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Extrema::min() const {
  // @@protoc_insertion_point(field_list:Messages.Extrema.min)
  return _internal_min();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Extrema::_internal_mutable_min() {
  return &min_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Extrema::mutable_min() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Extrema.min)
  return _internal_mutable_min();
}

// repeated double max = 3 [packed = true];
inline int Extrema::_internal_max_size() const {
  return max_.size();
}
inline int Extrema::max_size() const {
  return _internal_max_size();
}
inline void Extrema::clear_max() {
  max_.Clear();
}
inline double Extrema::_internal_max(int index) const {
  return max_.Get(index);
}
inline double Extrema::max(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Extrema.max)
  return _internal_max(index);
}
inline void Extrema::set_max(int index, double value) {
  max_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Extrema.max)
}
inline void Extrema::_internal_add_max(double value) {
  max_.Add(value);
}
inline void Extrema::add_max(double value) {
  _internal_add_max(value);
  // @@protoc_insertion_point(field_add:Messages.Extrema.max)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Extrema::_internal_max() const {
  return max_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Extrema::max() const {
  // @@protoc_insertion_point(field_list:Messages.Extrema.max)
  return _internal_max();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Extrema::_internal_mutable_max() {
  return &max_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Extrema::mutable_max() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Extrema.max)
  return _internal_mutable_max();
}

// bool is_set = 4;
inline void Extrema::clear_is_set() {
  is_set_ = false;
}
inline bool Extrema::_internal_is_set() const {
  return is_set_;
}
inline bool Extrema::is_set() const {
  // @@protoc_insertion_point(field_get:Messages.Extrema.is_set)
  return _internal_is_set();
}
inline void Extrema::_internal_set_is_set(bool value) {
  
  is_set_ = value;
}
inline void Extrema::set_is_set(bool value) {
  _internal_set_is_set(value);
  // @@protoc_insertion_point(field_set:Messages.Extrema.is_set)
}

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

// Vector32

// string name = 1;
inline void Vector32::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& Vector32::name() const {
  // @@protoc_insertion_point(field_get:Messages.Vector32.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Vector32::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Vector32.name)
}
inline std::string* Vector32::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:Messages.Vector32.name)
  return _s;
}
inline const std::string& Vector32::_internal_name() const {
  return name_.Get();
}
inline void Vector32::_internal_set_name(const std::string& value) {
  
  name_.Set(value, GetArenaForAllocation());
}
inline std::string* Vector32::_internal_mutable_name() {
  
  return name_.Mutable(GetArenaForAllocation());
}
inline std::string* Vector32::release_name() {
  // @@protoc_insertion_point(field_release:Messages.Vector32.name)
  return name_.Release();
}
inline void Vector32::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault()) {
    name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Vector32.name)
}

// uint32 components = 2;
inline void Vector32::clear_components() {
  components_ = 0u;
}
inline uint32_t Vector32::_internal_components() const {
  return components_;
}
inline uint32_t Vector32::components() const {
  // @@protoc_insertion_point(field_get:Messages.Vector32.components)
  return _internal_components();
}
inline void Vector32::_internal_set_components(uint32_t value) {
  
  components_ = value;
}
inline void Vector32::set_components(uint32_t value) {
  _internal_set_components(value);
  // @@protoc_insertion_point(field_set:Messages.Vector32.components)
}

// bool interleaved = 3;
inline void Vector32::clear_interleaved() {
  interleaved_ = false;
}
inline bool Vector32::_internal_interleaved() const {
  return interleaved_;
}
inline bool Vector32::interleaved() const {
  // @@protoc_insertion_point(field_get:Messages.Vector32.interleaved)
  return _internal_interleaved();
}
inline void Vector32::_internal_set_interleaved(bool value) {
  
  interleaved_ = value;
}
inline void Vector32::set_interleaved(bool value) {
  _internal_set_interleaved(value);
  // @@protoc_insertion_point(field_set:Messages.Vector32.interleaved)
}

// .Messages.Revision revision = 4;
inline bool Vector32::_internal_has_revision() const {
  return this != internal_default_instance() && revision_ != nullptr;
}
inline bool Vector32::has_revision() const {
  return _internal_has_revision();
}
inline void Vector32::clear_revision() {
  if (GetArenaForAllocation() == nullptr && revision_ != nullptr) {
    delete revision_;
  }
  revision_ = nullptr;
}
inline const ::Messages::Revision& Vector32::_internal_revision() const {
  const ::Messages::Revision* p = revision_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Revision&>(
      ::Messages::_Revision_default_instance_);
}
inline const ::Messages::Revision& Vector32::revision() const {
  // @@protoc_insertion_point(field_get:Messages.Vector32.revision)
  return _internal_revision();
}
inline void Vector32::unsafe_arena_set_allocated_revision(
    ::Messages::Revision* revision) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(revision_);
  }
  revision_ = revision;
  if (revision) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.Vector32.revision)
}
inline ::Messages::Revision* Vector32::release_revision() {
  
  ::Messages::Revision* temp = revision_;
  revision_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::Messages::Revision* Vector32::unsafe_arena_release_revision() {
  // @@protoc_insertion_point(field_release:Messages.Vector32.revision)
  
  ::Messages::Revision* temp = revision_;
  revision_ = nullptr;
  return temp;
}
inline ::Messages::Revision* Vector32::_internal_mutable_revision() {
  
  if (revision_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Revision>(GetArenaForAllocation());
    revision_ = p;
  }
  return revision_;
}
inline ::Messages::Revision* Vector32::mutable_revision() {
  ::Messages::Revision* _msg = _internal_mutable_revision();
  // @@protoc_insertion_point(field_mutable:Messages.Vector32.revision)
  return _msg;
}
inline void Vector32::set_allocated_revision(::Messages::Revision* revision) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete revision_;
  }
  if (revision) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(revision);
    if (message_arena != submessage_arena) {
      revision = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, revision, submessage_arena);
    }
    
  } else {
    
  }
  revision_ = revision;
  // @@protoc_insertion_point(field_set_allocated:Messages.Vector32.revision)
}

// string units = 5;
inline void Vector32::clear_units() {
  units_.ClearToEmpty();
}
inline const std::string& Vector32::units() const {
  // @@protoc_insertion_point(field_get:Messages.Vector32.units)
  return _internal_units();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Vector32::set_units(ArgT0&& arg0, ArgT... args) {
 
 units_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Vector32.units)
}
inline std::string* Vector32::mutable_units() {
  std::string* _s = _internal_mutable_units();
  // @@protoc_insertion_point(field_mutable:Messages.Vector32.units)
  return _s;
}
inline const std::string& Vector32::_internal_units() const {
  return units_.Get();
}
inline void Vector32::_internal_set_units(const std::string& value) {
  
  units_.Set(value, GetArenaForAllocation());
}
inline std::string* Vector32::_internal_mutable_units() {
  
  return units_.Mutable(GetArenaForAllocation());
}
inline std::string* Vector32::release_units() {
  // @@protoc_insertion_point(field_release:Messages.Vector32.units)
  return units_.Release();
}
inline void Vector32::set_allocated_units(std::string* units) {
  if (units != nullptr) {
    
  } else {
    
  }
  units_.SetAllocated(units, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (units_.IsDefault()) {
    units_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Vector32.units)
}

// string comment = 6;
inline void Vector32::clear_comment() {
  comment_.ClearToEmpty();
}
inline const std::string& Vector32::comment() const {
  // @@protoc_insertion_point(field_get:Messages.Vector32.comment)
  return _internal_comment();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Vector32::set_comment(ArgT0&& arg0, ArgT... args) {
 
 comment_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Vector32.comment)
}
inline std::string* Vector32::mutable_comment() {
  std::string* _s = _internal_mutable_comment();
  // @@protoc_insertion_point(field_mutable:Messages.Vector32.comment)
  return _s;
}
inline const std::string& Vector32::_internal_comment() const {
  return comment_.Get();
}
inline void Vector32::_internal_set_comment(const std::string& value) {
  
  comment_.Set(value, GetArenaForAllocation());
}
inline std::string* Vector32::_internal_mutable_comment() {
  
  return comment_.Mutable(GetArenaForAllocation());
}
inline std::string* Vector32::release_comment() {
  // @@protoc_insertion_point(field_release:Messages.Vector32.comment)
  return comment_.Release();
}
inline void Vector32::set_allocated_comment(std::string* comment) {
  if (comment != nullptr) {
    
  } else {
    
  }
  comment_.SetAllocated(comment, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (comment_.IsDefault()) {
    comment_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Vector32.comment)
}

// uint64 offset = 9;
inline void Vector32::clear_offset() {
  offset_ = uint64_t{0u};
}
inline uint64_t Vector32::_internal_offset() const {
  return offset_;
}
inline uint64_t Vector32::offset() const {
  // @@protoc_insertion_point(field_get:Messages.Vector32.offset)
  return _internal_offset();
}
inline void Vector32::_internal_set_offset(uint64_t value) {
  
  offset_ = value;
}
inline void Vector32::set_offset(uint64_t value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:Messages.Vector32.offset)
}

// repeated float values = 10 [packed = true];
inline int Vector32::_internal_values_size() const {
  return values_.size();
}
inline int Vector32::values_size() const {
  return _internal_values_size();
}
inline void Vector32::clear_values() {
  values_.Clear();
}
inline float Vector32::_internal_values(int index) const {
  return values_.Get(index);
}
inline float Vector32::values(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Vector32.values)
  return _internal_values(index);
}
inline void Vector32::set_values(int index, float value) {
  values_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Vector32.values)
}
inline void Vector32::_internal_add_values(float value) {
  values_.Add(value);
}
inline void Vector32::add_values(float value) {
  _internal_add_values(value);
  // @@protoc_insertion_point(field_add:Messages.Vector32.values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
Vector32::_internal_values() const {
  return values_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
Vector32::values() const {
  // @@protoc_insertion_point(field_list:Messages.Vector32.values)
  return _internal_values();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
Vector32::_internal_mutable_values() {
  return &values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
Vector32::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Vector32.values)
  return _internal_mutable_values();
}

// repeated uint32 size_hint = 11 [packed = true];
inline int Vector32::_internal_size_hint_size() const {
  return size_hint_.size();
}
inline int Vector32::size_hint_size() const {
  return _internal_size_hint_size();
}
inline void Vector32::clear_size_hint() {
  size_hint_.Clear();
}
inline uint32_t Vector32::_internal_size_hint(int index) const {
  return size_hint_.Get(index);
}
inline uint32_t Vector32::size_hint(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Vector32.size_hint)
  return _internal_size_hint(index);
}
inline void Vector32::set_size_hint(int index, uint32_t value) {
  size_hint_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Vector32.size_hint)
}
inline void Vector32::_internal_add_size_hint(uint32_t value) {
  size_hint_.Add(value);
}
inline void Vector32::add_size_hint(uint32_t value) {
  _internal_add_size_hint(value);
  // @@protoc_insertion_point(field_add:Messages.Vector32.size_hint)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Vector32::_internal_size_hint() const {
  return size_hint_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Vector32::size_hint() const {
  // @@protoc_insertion_point(field_list:Messages.Vector32.size_hint)
  return _internal_size_hint();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Vector32::_internal_mutable_size_hint() {
  return &size_hint_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Vector32::mutable_size_hint() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Vector32.size_hint)
  return _internal_mutable_size_hint();
}

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

// Vector64

// string name = 1;
inline void Vector64::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& Vector64::name() const {
  // @@protoc_insertion_point(field_get:Messages.Vector64.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Vector64::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Vector64.name)
}
inline std::string* Vector64::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:Messages.Vector64.name)
  return _s;
}
inline const std::string& Vector64::_internal_name() const {
  return name_.Get();
}
inline void Vector64::_internal_set_name(const std::string& value) {
  
  name_.Set(value, GetArenaForAllocation());
}
inline std::string* Vector64::_internal_mutable_name() {
  
  return name_.Mutable(GetArenaForAllocation());
}
inline std::string* Vector64::release_name() {
  // @@protoc_insertion_point(field_release:Messages.Vector64.name)
  return name_.Release();
}
inline void Vector64::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault()) {
    name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Vector64.name)
}

// uint32 components = 2;
inline void Vector64::clear_components() {
  components_ = 0u;
}
inline uint32_t Vector64::_internal_components() const {
  return components_;
}
inline uint32_t Vector64::components() const {
  // @@protoc_insertion_point(field_get:Messages.Vector64.components)
  return _internal_components();
}
inline void Vector64::_internal_set_components(uint32_t value) {
  
  components_ = value;
}
inline void Vector64::set_components(uint32_t value) {
  _internal_set_components(value);
  // @@protoc_insertion_point(field_set:Messages.Vector64.components)
}

// bool interleaved = 3;
inline void Vector64::clear_interleaved() {
  interleaved_ = false;
}
inline bool Vector64::_internal_interleaved() const {
  return interleaved_;
}
inline bool Vector64::interleaved() const {
  // @@protoc_insertion_point(field_get:Messages.Vector64.interleaved)
  return _internal_interleaved();
}
inline void Vector64::_internal_set_interleaved(bool value) {
  
  interleaved_ = value;
}
inline void Vector64::set_interleaved(bool value) {
  _internal_set_interleaved(value);
  // @@protoc_insertion_point(field_set:Messages.Vector64.interleaved)
}

// .Messages.Revision revision = 4;
inline bool Vector64::_internal_has_revision() const {
  return this != internal_default_instance() && revision_ != nullptr;
}
inline bool Vector64::has_revision() const {
  return _internal_has_revision();
}
inline void Vector64::clear_revision() {
  if (GetArenaForAllocation() == nullptr && revision_ != nullptr) {
    delete revision_;
  }
  revision_ = nullptr;
}
inline const ::Messages::Revision& Vector64::_internal_revision() const {
  const ::Messages::Revision* p = revision_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Revision&>(
      ::Messages::_Revision_default_instance_);
}
inline const ::Messages::Revision& Vector64::revision() const {
  // @@protoc_insertion_point(field_get:Messages.Vector64.revision)
  return _internal_revision();
}
inline void Vector64::unsafe_arena_set_allocated_revision(
    ::Messages::Revision* revision) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(revision_);
  }
  revision_ = revision;
  if (revision) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.Vector64.revision)
}
inline ::Messages::Revision* Vector64::release_revision() {
  
  ::Messages::Revision* temp = revision_;
  revision_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::Messages::Revision* Vector64::unsafe_arena_release_revision() {
  // @@protoc_insertion_point(field_release:Messages.Vector64.revision)
  
  ::Messages::Revision* temp = revision_;
  revision_ = nullptr;
  return temp;
}
inline ::Messages::Revision* Vector64::_internal_mutable_revision() {
  
  if (revision_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Revision>(GetArenaForAllocation());
    revision_ = p;
  }
  return revision_;
}
inline ::Messages::Revision* Vector64::mutable_revision() {
  ::Messages::Revision* _msg = _internal_mutable_revision();
  // @@protoc_insertion_point(field_mutable:Messages.Vector64.revision)
  return _msg;
}
inline void Vector64::set_allocated_revision(::Messages::Revision* revision) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete revision_;
  }
  if (revision) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(revision);
    if (message_arena != submessage_arena) {
      revision = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, revision, submessage_arena);
    }
    
  } else {
    
  }
  revision_ = revision;
  // @@protoc_insertion_point(field_set_allocated:Messages.Vector64.revision)
}

// string units = 5;
inline void Vector64::clear_units() {
  units_.ClearToEmpty();
}
inline const std::string& Vector64::units() const {
  // @@protoc_insertion_point(field_get:Messages.Vector64.units)
  return _internal_units();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Vector64::set_units(ArgT0&& arg0, ArgT... args) {
 
 units_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Vector64.units)
}
inline std::string* Vector64::mutable_units() {
  std::string* _s = _internal_mutable_units();
  // @@protoc_insertion_point(field_mutable:Messages.Vector64.units)
  return _s;
}
inline const std::string& Vector64::_internal_units() const {
  return units_.Get();
}
inline void Vector64::_internal_set_units(const std::string& value) {
  
  units_.Set(value, GetArenaForAllocation());
}
inline std::string* Vector64::_internal_mutable_units() {
  
  return units_.Mutable(GetArenaForAllocation());
}
inline std::string* Vector64::release_units() {
  // @@protoc_insertion_point(field_release:Messages.Vector64.units)
  return units_.Release();
}
inline void Vector64::set_allocated_units(std::string* units) {
  if (units != nullptr) {
    
  } else {
    
  }
  units_.SetAllocated(units, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (units_.IsDefault()) {
    units_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Vector64.units)
}

// string comment = 6;
inline void Vector64::clear_comment() {
  comment_.ClearToEmpty();
}
inline const std::string& Vector64::comment() const {
  // @@protoc_insertion_point(field_get:Messages.Vector64.comment)
  return _internal_comment();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Vector64::set_comment(ArgT0&& arg0, ArgT... args) {
 
 comment_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Vector64.comment)
}
inline std::string* Vector64::mutable_comment() {
  std::string* _s = _internal_mutable_comment();
  // @@protoc_insertion_point(field_mutable:Messages.Vector64.comment)
  return _s;
}
inline const std::string& Vector64::_internal_comment() const {
  return comment_.Get();
}
inline void Vector64::_internal_set_comment(const std::string& value) {
  
  comment_.Set(value, GetArenaForAllocation());
}
inline std::string* Vector64::_internal_mutable_comment() {
  
  return comment_.Mutable(GetArenaForAllocation());
}
inline std::string* Vector64::release_comment() {
  // @@protoc_insertion_point(field_release:Messages.Vector64.comment)
  return comment_.Release();
}
inline void Vector64::set_allocated_comment(std::string* comment) {
  if (comment != nullptr) {
    
  } else {
    
  }
  comment_.SetAllocated(comment, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (comment_.IsDefault()) {
    comment_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Vector64.comment)
}

// uint64 offset = 9;
inline void Vector64::clear_offset() {
  offset_ = uint64_t{0u};
}
inline uint64_t Vector64::_internal_offset() const {
  return offset_;
}
inline uint64_t Vector64::offset() const {
  // @@protoc_insertion_point(field_get:Messages.Vector64.offset)
  return _internal_offset();
}
inline void Vector64::_internal_set_offset(uint64_t value) {
  
  offset_ = value;
}
inline void Vector64::set_offset(uint64_t value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:Messages.Vector64.offset)
}

// repeated double values = 10 [packed = true];
inline int Vector64::_internal_values_size() const {
  return values_.size();
}
inline int Vector64::values_size() const {
  return _internal_values_size();
}
inline void Vector64::clear_values() {
  values_.Clear();
}
inline double Vector64::_internal_values(int index) const {
  return values_.Get(index);
}
inline double Vector64::values(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Vector64.values)
  return _internal_values(index);
}
inline void Vector64::set_values(int index, double value) {
  values_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Vector64.values)
}
inline void Vector64::_internal_add_values(double value) {
  values_.Add(value);
}
inline void Vector64::add_values(double value) {
  _internal_add_values(value);
  // @@protoc_insertion_point(field_add:Messages.Vector64.values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Vector64::_internal_values() const {
  return values_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Vector64::values() const {
  // @@protoc_insertion_point(field_list:Messages.Vector64.values)
  return _internal_values();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Vector64::_internal_mutable_values() {
  return &values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Vector64::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Vector64.values)
  return _internal_mutable_values();
}

// repeated uint32 size_hint = 11 [packed = true];
inline int Vector64::_internal_size_hint_size() const {
  return size_hint_.size();
}
inline int Vector64::size_hint_size() const {
  return _internal_size_hint_size();
}
inline void Vector64::clear_size_hint() {
  size_hint_.Clear();
}
inline uint32_t Vector64::_internal_size_hint(int index) const {
  return size_hint_.Get(index);
}
inline uint32_t Vector64::size_hint(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Vector64.size_hint)
  return _internal_size_hint(index);
}
inline void Vector64::set_size_hint(int index, uint32_t value) {
  size_hint_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Vector64.size_hint)
}
inline void Vector64::_internal_add_size_hint(uint32_t value) {
  size_hint_.Add(value);
}
inline void Vector64::add_size_hint(uint32_t value) {
  _internal_add_size_hint(value);
  // @@protoc_insertion_point(field_add:Messages.Vector64.size_hint)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Vector64::_internal_size_hint() const {
  return size_hint_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Vector64::size_hint() const {
  // @@protoc_insertion_point(field_list:Messages.Vector64.size_hint)
  return _internal_size_hint();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Vector64::_internal_mutable_size_hint() {
  return &size_hint_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Vector64::mutable_size_hint() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Vector64.size_hint)
  return _internal_mutable_size_hint();
}

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

// SparseMatrix

// string name = 1;
inline void SparseMatrix::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& SparseMatrix::name() const {
  // @@protoc_insertion_point(field_get:Messages.SparseMatrix.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SparseMatrix::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.SparseMatrix.name)
}
inline std::string* SparseMatrix::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:Messages.SparseMatrix.name)
  return _s;
}
inline const std::string& SparseMatrix::_internal_name() const {
  return name_.Get();
}
inline void SparseMatrix::_internal_set_name(const std::string& value) {
  
  name_.Set(value, GetArenaForAllocation());
}
inline std::string* SparseMatrix::_internal_mutable_name() {
  
  return name_.Mutable(GetArenaForAllocation());
}
inline std::string* SparseMatrix::release_name() {
  // @@protoc_insertion_point(field_release:Messages.SparseMatrix.name)
  return name_.Release();
}
inline void SparseMatrix::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault()) {
    name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.SparseMatrix.name)
}

// repeated uint32 size_hint = 2 [packed = true];
inline int SparseMatrix::_internal_size_hint_size() const {
  return size_hint_.size();
}
inline int SparseMatrix::size_hint_size() const {
  return _internal_size_hint_size();
}
inline void SparseMatrix::clear_size_hint() {
  size_hint_.Clear();
}
inline uint32_t SparseMatrix::_internal_size_hint(int index) const {
  return size_hint_.Get(index);
}
inline uint32_t SparseMatrix::size_hint(int index) const {
  // @@protoc_insertion_point(field_get:Messages.SparseMatrix.size_hint)
  return _internal_size_hint(index);
}
inline void SparseMatrix::set_size_hint(int index, uint32_t value) {
  size_hint_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.SparseMatrix.size_hint)
}
inline void SparseMatrix::_internal_add_size_hint(uint32_t value) {
  size_hint_.Add(value);
}
inline void SparseMatrix::add_size_hint(uint32_t value) {
  _internal_add_size_hint(value);
  // @@protoc_insertion_point(field_add:Messages.SparseMatrix.size_hint)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
SparseMatrix::_internal_size_hint() const {
  return size_hint_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
SparseMatrix::size_hint() const {
  // @@protoc_insertion_point(field_list:Messages.SparseMatrix.size_hint)
  return _internal_size_hint();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
SparseMatrix::_internal_mutable_size_hint() {
  return &size_hint_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
SparseMatrix::mutable_size_hint() {
  // @@protoc_insertion_point(field_mutable_list:Messages.SparseMatrix.size_hint)
  return _internal_mutable_size_hint();
}

// repeated uint32 indices = 3 [packed = true];
inline int SparseMatrix::_internal_indices_size() const {
  return indices_.size();
}
inline int SparseMatrix::indices_size() const {
  return _internal_indices_size();
}
inline void SparseMatrix::clear_indices() {
  indices_.Clear();
}
inline uint32_t SparseMatrix::_internal_indices(int index) const {
  return indices_.Get(index);
}
inline uint32_t SparseMatrix::indices(int index) const {
  // @@protoc_insertion_point(field_get:Messages.SparseMatrix.indices)
  return _internal_indices(index);
}
inline void SparseMatrix::set_indices(int index, uint32_t value) {
  indices_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.SparseMatrix.indices)
}
inline void SparseMatrix::_internal_add_indices(uint32_t value) {
  indices_.Add(value);
}
inline void SparseMatrix::add_indices(uint32_t value) {
  _internal_add_indices(value);
  // @@protoc_insertion_point(field_add:Messages.SparseMatrix.indices)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
SparseMatrix::_internal_indices() const {
  return indices_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
SparseMatrix::indices() const {
  // @@protoc_insertion_point(field_list:Messages.SparseMatrix.indices)
  return _internal_indices();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
SparseMatrix::_internal_mutable_indices() {
  return &indices_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
SparseMatrix::mutable_indices() {
  // @@protoc_insertion_point(field_mutable_list:Messages.SparseMatrix.indices)
  return _internal_mutable_indices();
}

// repeated double values = 4 [packed = true];
inline int SparseMatrix::_internal_values_size() const {
  return values_.size();
}
inline int SparseMatrix::values_size() const {
  return _internal_values_size();
}
inline void SparseMatrix::clear_values() {
  values_.Clear();
}
inline double SparseMatrix::_internal_values(int index) const {
  return values_.Get(index);
}
inline double SparseMatrix::values(int index) const {
  // @@protoc_insertion_point(field_get:Messages.SparseMatrix.values)
  return _internal_values(index);
}
inline void SparseMatrix::set_values(int index, double value) {
  values_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.SparseMatrix.values)
}
inline void SparseMatrix::_internal_add_values(double value) {
  values_.Add(value);
}
inline void SparseMatrix::add_values(double value) {
  _internal_add_values(value);
  // @@protoc_insertion_point(field_add:Messages.SparseMatrix.values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
SparseMatrix::_internal_values() const {
  return values_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
SparseMatrix::values() const {
  // @@protoc_insertion_point(field_list:Messages.SparseMatrix.values)
  return _internal_values();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
SparseMatrix::_internal_mutable_values() {
  return &values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
SparseMatrix::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:Messages.SparseMatrix.values)
  return _internal_mutable_values();
}

// .Messages.Extrema bounds = 5;
inline bool SparseMatrix::_internal_has_bounds() const {
  return this != internal_default_instance() && bounds_ != nullptr;
}
inline bool SparseMatrix::has_bounds() const {
  return _internal_has_bounds();
}
inline void SparseMatrix::clear_bounds() {
  if (GetArenaForAllocation() == nullptr && bounds_ != nullptr) {
    delete bounds_;
  }
  bounds_ = nullptr;
}
inline const ::Messages::Extrema& SparseMatrix::_internal_bounds() const {
  const ::Messages::Extrema* p = bounds_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Extrema&>(
      ::Messages::_Extrema_default_instance_);
}
inline const ::Messages::Extrema& SparseMatrix::bounds() const {
  // @@protoc_insertion_point(field_get:Messages.SparseMatrix.bounds)
  return _internal_bounds();
}
inline void SparseMatrix::unsafe_arena_set_allocated_bounds(
    ::Messages::Extrema* bounds) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bounds_);
  }
  bounds_ = bounds;
  if (bounds) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.SparseMatrix.bounds)
}
inline ::Messages::Extrema* SparseMatrix::release_bounds() {
  
  ::Messages::Extrema* temp = bounds_;
  bounds_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::Messages::Extrema* SparseMatrix::unsafe_arena_release_bounds() {
  // @@protoc_insertion_point(field_release:Messages.SparseMatrix.bounds)
  
  ::Messages::Extrema* temp = bounds_;
  bounds_ = nullptr;
  return temp;
}
inline ::Messages::Extrema* SparseMatrix::_internal_mutable_bounds() {
  
  if (bounds_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Extrema>(GetArenaForAllocation());
    bounds_ = p;
  }
  return bounds_;
}
inline ::Messages::Extrema* SparseMatrix::mutable_bounds() {
  ::Messages::Extrema* _msg = _internal_mutable_bounds();
  // @@protoc_insertion_point(field_mutable:Messages.SparseMatrix.bounds)
  return _msg;
}
inline void SparseMatrix::set_allocated_bounds(::Messages::Extrema* bounds) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete bounds_;
  }
  if (bounds) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(bounds);
    if (message_arena != submessage_arena) {
      bounds = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bounds, submessage_arena);
    }
    
  } else {
    
  }
  bounds_ = bounds;
  // @@protoc_insertion_point(field_set_allocated:Messages.SparseMatrix.bounds)
}

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

// Rule

// string pk = 1;
inline void Rule::clear_pk() {
  pk_.ClearToEmpty();
}
inline const std::string& Rule::pk() const {
  // @@protoc_insertion_point(field_get:Messages.Rule.pk)
  return _internal_pk();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Rule::set_pk(ArgT0&& arg0, ArgT... args) {
 
 pk_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Rule.pk)
}
inline std::string* Rule::mutable_pk() {
  std::string* _s = _internal_mutable_pk();
  // @@protoc_insertion_point(field_mutable:Messages.Rule.pk)
  return _s;
}
inline const std::string& Rule::_internal_pk() const {
  return pk_.Get();
}
inline void Rule::_internal_set_pk(const std::string& value) {
  
  pk_.Set(value, GetArenaForAllocation());
}
inline std::string* Rule::_internal_mutable_pk() {
  
  return pk_.Mutable(GetArenaForAllocation());
}
inline std::string* Rule::release_pk() {
  // @@protoc_insertion_point(field_release:Messages.Rule.pk)
  return pk_.Release();
}
inline void Rule::set_allocated_pk(std::string* pk) {
  if (pk != nullptr) {
    
  } else {
    
  }
  pk_.SetAllocated(pk, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (pk_.IsDefault()) {
    pk_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Rule.pk)
}

// uint32 op = 2;
inline void Rule::clear_op() {
  op_ = 0u;
}
inline uint32_t Rule::_internal_op() const {
  return op_;
}
inline uint32_t Rule::op() const {
  // @@protoc_insertion_point(field_get:Messages.Rule.op)
  return _internal_op();
}
inline void Rule::_internal_set_op(uint32_t value) {
  
  op_ = value;
}
inline void Rule::set_op(uint32_t value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:Messages.Rule.op)
}

// double value = 3;
inline void Rule::clear_value() {
  value_ = 0;
}
inline double Rule::_internal_value() const {
  return value_;
}
inline double Rule::value() const {
  // @@protoc_insertion_point(field_get:Messages.Rule.value)
  return _internal_value();
}
inline void Rule::_internal_set_value(double value) {
  
  value_ = value;
}
inline void Rule::set_value(double value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:Messages.Rule.value)
}

// repeated string algorithms = 4;
inline int Rule::_internal_algorithms_size() const {
  return algorithms_.size();
}
inline int Rule::algorithms_size() const {
  return _internal_algorithms_size();
}
inline void Rule::clear_algorithms() {
  algorithms_.Clear();
}
inline std::string* Rule::add_algorithms() {
  std::string* _s = _internal_add_algorithms();
  // @@protoc_insertion_point(field_add_mutable:Messages.Rule.algorithms)
  return _s;
}
inline const std::string& Rule::_internal_algorithms(int index) const {
  return algorithms_.Get(index);
}
inline const std::string& Rule::algorithms(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Rule.algorithms)
  return _internal_algorithms(index);
}
inline std::string* Rule::mutable_algorithms(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Rule.algorithms)
  return algorithms_.Mutable(index);
}
inline void Rule::set_algorithms(int index, const std::string& value) {
  algorithms_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Rule.algorithms)
}
inline void Rule::set_algorithms(int index, std::string&& value) {
  algorithms_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Rule.algorithms)
}
inline void Rule::set_algorithms(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  algorithms_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Rule.algorithms)
}
inline void Rule::set_algorithms(int index, const char* value, size_t size) {
  algorithms_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Rule.algorithms)
}
inline std::string* Rule::_internal_add_algorithms() {
  return algorithms_.Add();
}
inline void Rule::add_algorithms(const std::string& value) {
  algorithms_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Rule.algorithms)
}
inline void Rule::add_algorithms(std::string&& value) {
  algorithms_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Rule.algorithms)
}
inline void Rule::add_algorithms(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  algorithms_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Rule.algorithms)
}
inline void Rule::add_algorithms(const char* value, size_t size) {
  algorithms_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Rule.algorithms)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Rule::algorithms() const {
  // @@protoc_insertion_point(field_list:Messages.Rule.algorithms)
  return algorithms_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Rule::mutable_algorithms() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Rule.algorithms)
  return &algorithms_;
}

// repeated uint32 failed_nodes = 5 [packed = true];
inline int Rule::_internal_failed_nodes_size() const {
  return failed_nodes_.size();
}
inline int Rule::failed_nodes_size() const {
  return _internal_failed_nodes_size();
}
inline void Rule::clear_failed_nodes() {
  failed_nodes_.Clear();
}
inline uint32_t Rule::_internal_failed_nodes(int index) const {
  return failed_nodes_.Get(index);
}
inline uint32_t Rule::failed_nodes(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Rule.failed_nodes)
  return _internal_failed_nodes(index);
}
inline void Rule::set_failed_nodes(int index, uint32_t value) {
  failed_nodes_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Rule.failed_nodes)
}
inline void Rule::_internal_add_failed_nodes(uint32_t value) {
  failed_nodes_.Add(value);
}
inline void Rule::add_failed_nodes(uint32_t value) {
  _internal_add_failed_nodes(value);
  // @@protoc_insertion_point(field_add:Messages.Rule.failed_nodes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Rule::_internal_failed_nodes() const {
  return failed_nodes_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Rule::failed_nodes() const {
  // @@protoc_insertion_point(field_list:Messages.Rule.failed_nodes)
  return _internal_failed_nodes();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Rule::_internal_mutable_failed_nodes() {
  return &failed_nodes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Rule::mutable_failed_nodes() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Rule.failed_nodes)
  return _internal_mutable_failed_nodes();
}

// repeated double failed_values = 6 [packed = true];
inline int Rule::_internal_failed_values_size() const {
  return failed_values_.size();
}
inline int Rule::failed_values_size() const {
  return _internal_failed_values_size();
}
inline void Rule::clear_failed_values() {
  failed_values_.Clear();
}
inline double Rule::_internal_failed_values(int index) const {
  return failed_values_.Get(index);
}
inline double Rule::failed_values(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Rule.failed_values)
  return _internal_failed_values(index);
}
inline void Rule::set_failed_values(int index, double value) {
  failed_values_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Rule.failed_values)
}
inline void Rule::_internal_add_failed_values(double value) {
  failed_values_.Add(value);
}
inline void Rule::add_failed_values(double value) {
  _internal_add_failed_values(value);
  // @@protoc_insertion_point(field_add:Messages.Rule.failed_values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Rule::_internal_failed_values() const {
  return failed_values_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Rule::failed_values() const {
  // @@protoc_insertion_point(field_list:Messages.Rule.failed_values)
  return _internal_failed_values();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Rule::_internal_mutable_failed_values() {
  return &failed_values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Rule::mutable_failed_values() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Rule.failed_values)
  return _internal_mutable_failed_values();
}

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

// Record64

// string name = 1;
inline void Record64::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& Record64::name() const {
  // @@protoc_insertion_point(field_get:Messages.Record64.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Record64::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Record64.name)
}
inline std::string* Record64::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:Messages.Record64.name)
  return _s;
}
inline const std::string& Record64::_internal_name() const {
  return name_.Get();
}
inline void Record64::_internal_set_name(const std::string& value) {
  
  name_.Set(value, GetArenaForAllocation());
}
inline std::string* Record64::_internal_mutable_name() {
  
  return name_.Mutable(GetArenaForAllocation());
}
inline std::string* Record64::release_name() {
  // @@protoc_insertion_point(field_release:Messages.Record64.name)
  return name_.Release();
}
inline void Record64::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault()) {
    name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Record64.name)
}

// string owner = 2;
inline void Record64::clear_owner() {
  owner_.ClearToEmpty();
}
inline const std::string& Record64::owner() const {
  // @@protoc_insertion_point(field_get:Messages.Record64.owner)
  return _internal_owner();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Record64::set_owner(ArgT0&& arg0, ArgT... args) {
 
 owner_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Record64.owner)
}
inline std::string* Record64::mutable_owner() {
  std::string* _s = _internal_mutable_owner();
  // @@protoc_insertion_point(field_mutable:Messages.Record64.owner)
  return _s;
}
inline const std::string& Record64::_internal_owner() const {
  return owner_.Get();
}
inline void Record64::_internal_set_owner(const std::string& value) {
  
  owner_.Set(value, GetArenaForAllocation());
}
inline std::string* Record64::_internal_mutable_owner() {
  
  return owner_.Mutable(GetArenaForAllocation());
}
inline std::string* Record64::release_owner() {
  // @@protoc_insertion_point(field_release:Messages.Record64.owner)
  return owner_.Release();
}
inline void Record64::set_allocated_owner(std::string* owner) {
  if (owner != nullptr) {
    
  } else {
    
  }
  owner_.SetAllocated(owner, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (owner_.IsDefault()) {
    owner_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Record64.owner)
}

// .Messages.Revision revision = 3;
inline bool Record64::_internal_has_revision() const {
  return this != internal_default_instance() && revision_ != nullptr;
}
inline bool Record64::has_revision() const {
  return _internal_has_revision();
}
inline void Record64::clear_revision() {
  if (GetArenaForAllocation() == nullptr && revision_ != nullptr) {
    delete revision_;
  }
  revision_ = nullptr;
}
inline const ::Messages::Revision& Record64::_internal_revision() const {
  const ::Messages::Revision* p = revision_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Revision&>(
      ::Messages::_Revision_default_instance_);
}
inline const ::Messages::Revision& Record64::revision() const {
  // @@protoc_insertion_point(field_get:Messages.Record64.revision)
  return _internal_revision();
}
inline void Record64::unsafe_arena_set_allocated_revision(
    ::Messages::Revision* revision) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(revision_);
  }
  revision_ = revision;
  if (revision) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.Record64.revision)
}
inline ::Messages::Revision* Record64::release_revision() {
  
  ::Messages::Revision* temp = revision_;
  revision_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::Messages::Revision* Record64::unsafe_arena_release_revision() {
  // @@protoc_insertion_point(field_release:Messages.Record64.revision)
  
  ::Messages::Revision* temp = revision_;
  revision_ = nullptr;
  return temp;
}
inline ::Messages::Revision* Record64::_internal_mutable_revision() {
  
  if (revision_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Revision>(GetArenaForAllocation());
    revision_ = p;
  }
  return revision_;
}
inline ::Messages::Revision* Record64::mutable_revision() {
  ::Messages::Revision* _msg = _internal_mutable_revision();
  // @@protoc_insertion_point(field_mutable:Messages.Record64.revision)
  return _msg;
}
inline void Record64::set_allocated_revision(::Messages::Revision* revision) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete revision_;
  }
  if (revision) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(revision);
    if (message_arena != submessage_arena) {
      revision = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, revision, submessage_arena);
    }
    
  } else {
    
  }
  revision_ = revision;
  // @@protoc_insertion_point(field_set_allocated:Messages.Record64.revision)
}

// uint32 length_units = 8;
inline void Record64::clear_length_units() {
  length_units_ = 0u;
}
inline uint32_t Record64::_internal_length_units() const {
  return length_units_;
}
inline uint32_t Record64::length_units() const {
  // @@protoc_insertion_point(field_get:Messages.Record64.length_units)
  return _internal_length_units();
}
inline void Record64::_internal_set_length_units(uint32_t value) {
  
  length_units_ = value;
}
inline void Record64::set_length_units(uint32_t value) {
  _internal_set_length_units(value);
  // @@protoc_insertion_point(field_set:Messages.Record64.length_units)
}

// repeated .Messages.Rule requirements = 9;
inline int Record64::_internal_requirements_size() const {
  return requirements_.size();
}
inline int Record64::requirements_size() const {
  return _internal_requirements_size();
}
inline void Record64::clear_requirements() {
  requirements_.Clear();
}
inline ::Messages::Rule* Record64::mutable_requirements(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Record64.requirements)
  return requirements_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Rule >*
Record64::mutable_requirements() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Record64.requirements)
  return &requirements_;
}
inline const ::Messages::Rule& Record64::_internal_requirements(int index) const {
  return requirements_.Get(index);
}
inline const ::Messages::Rule& Record64::requirements(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Record64.requirements)
  return _internal_requirements(index);
}
inline ::Messages::Rule* Record64::_internal_add_requirements() {
  return requirements_.Add();
}
inline ::Messages::Rule* Record64::add_requirements() {
  ::Messages::Rule* _add = _internal_add_requirements();
  // @@protoc_insertion_point(field_add:Messages.Record64.requirements)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Rule >&
Record64::requirements() const {
  // @@protoc_insertion_point(field_list:Messages.Record64.requirements)
  return requirements_;
}

// repeated .Messages.Vector64 data = 10;
inline int Record64::_internal_data_size() const {
  return data_.size();
}
inline int Record64::data_size() const {
  return _internal_data_size();
}
inline void Record64::clear_data() {
  data_.Clear();
}
inline ::Messages::Vector64* Record64::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Record64.data)
  return data_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Vector64 >*
Record64::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Record64.data)
  return &data_;
}
inline const ::Messages::Vector64& Record64::_internal_data(int index) const {
  return data_.Get(index);
}
inline const ::Messages::Vector64& Record64::data(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Record64.data)
  return _internal_data(index);
}
inline ::Messages::Vector64* Record64::_internal_add_data() {
  return data_.Add();
}
inline ::Messages::Vector64* Record64::add_data() {
  ::Messages::Vector64* _add = _internal_add_data();
  // @@protoc_insertion_point(field_add:Messages.Record64.data)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Vector64 >&
Record64::data() const {
  // @@protoc_insertion_point(field_list:Messages.Record64.data)
  return data_;
}

// repeated .Messages.SparseMatrix matrix = 11;
inline int Record64::_internal_matrix_size() const {
  return matrix_.size();
}
inline int Record64::matrix_size() const {
  return _internal_matrix_size();
}
inline void Record64::clear_matrix() {
  matrix_.Clear();
}
inline ::Messages::SparseMatrix* Record64::mutable_matrix(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Record64.matrix)
  return matrix_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::SparseMatrix >*
Record64::mutable_matrix() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Record64.matrix)
  return &matrix_;
}
inline const ::Messages::SparseMatrix& Record64::_internal_matrix(int index) const {
  return matrix_.Get(index);
}
inline const ::Messages::SparseMatrix& Record64::matrix(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Record64.matrix)
  return _internal_matrix(index);
}
inline ::Messages::SparseMatrix* Record64::_internal_add_matrix() {
  return matrix_.Add();
}
inline ::Messages::SparseMatrix* Record64::add_matrix() {
  ::Messages::SparseMatrix* _add = _internal_add_matrix();
  // @@protoc_insertion_point(field_add:Messages.Record64.matrix)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::SparseMatrix >&
Record64::matrix() const {
  // @@protoc_insertion_point(field_list:Messages.Record64.matrix)
  return matrix_;
}

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

// UIndices

// string name = 1;
inline void UIndices::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& UIndices::name() const {
  // @@protoc_insertion_point(field_get:Messages.UIndices.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UIndices::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.UIndices.name)
}
inline std::string* UIndices::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:Messages.UIndices.name)
  return _s;
}
inline const std::string& UIndices::_internal_name() const {
  return name_.Get();
}
inline void UIndices::_internal_set_name(const std::string& value) {
  
  name_.Set(value, GetArenaForAllocation());
}
inline std::string* UIndices::_internal_mutable_name() {
  
  return name_.Mutable(GetArenaForAllocation());
}
inline std::string* UIndices::release_name() {
  // @@protoc_insertion_point(field_release:Messages.UIndices.name)
  return name_.Release();
}
inline void UIndices::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault()) {
    name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.UIndices.name)
}

// uint32 components = 2;
inline void UIndices::clear_components() {
  components_ = 0u;
}
inline uint32_t UIndices::_internal_components() const {
  return components_;
}
inline uint32_t UIndices::components() const {
  // @@protoc_insertion_point(field_get:Messages.UIndices.components)
  return _internal_components();
}
inline void UIndices::_internal_set_components(uint32_t value) {
  
  components_ = value;
}
inline void UIndices::set_components(uint32_t value) {
  _internal_set_components(value);
  // @@protoc_insertion_point(field_set:Messages.UIndices.components)
}

// bool interleaved = 3;
inline void UIndices::clear_interleaved() {
  interleaved_ = false;
}
inline bool UIndices::_internal_interleaved() const {
  return interleaved_;
}
inline bool UIndices::interleaved() const {
  // @@protoc_insertion_point(field_get:Messages.UIndices.interleaved)
  return _internal_interleaved();
}
inline void UIndices::_internal_set_interleaved(bool value) {
  
  interleaved_ = value;
}
inline void UIndices::set_interleaved(bool value) {
  _internal_set_interleaved(value);
  // @@protoc_insertion_point(field_set:Messages.UIndices.interleaved)
}

// .Messages.Revision revision = 4;
inline bool UIndices::_internal_has_revision() const {
  return this != internal_default_instance() && revision_ != nullptr;
}
inline bool UIndices::has_revision() const {
  return _internal_has_revision();
}
inline void UIndices::clear_revision() {
  if (GetArenaForAllocation() == nullptr && revision_ != nullptr) {
    delete revision_;
  }
  revision_ = nullptr;
}
inline const ::Messages::Revision& UIndices::_internal_revision() const {
  const ::Messages::Revision* p = revision_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Revision&>(
      ::Messages::_Revision_default_instance_);
}
inline const ::Messages::Revision& UIndices::revision() const {
  // @@protoc_insertion_point(field_get:Messages.UIndices.revision)
  return _internal_revision();
}
inline void UIndices::unsafe_arena_set_allocated_revision(
    ::Messages::Revision* revision) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(revision_);
  }
  revision_ = revision;
  if (revision) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.UIndices.revision)
}
inline ::Messages::Revision* UIndices::release_revision() {
  
  ::Messages::Revision* temp = revision_;
  revision_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::Messages::Revision* UIndices::unsafe_arena_release_revision() {
  // @@protoc_insertion_point(field_release:Messages.UIndices.revision)
  
  ::Messages::Revision* temp = revision_;
  revision_ = nullptr;
  return temp;
}
inline ::Messages::Revision* UIndices::_internal_mutable_revision() {
  
  if (revision_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Revision>(GetArenaForAllocation());
    revision_ = p;
  }
  return revision_;
}
inline ::Messages::Revision* UIndices::mutable_revision() {
  ::Messages::Revision* _msg = _internal_mutable_revision();
  // @@protoc_insertion_point(field_mutable:Messages.UIndices.revision)
  return _msg;
}
inline void UIndices::set_allocated_revision(::Messages::Revision* revision) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete revision_;
  }
  if (revision) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(revision);
    if (message_arena != submessage_arena) {
      revision = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, revision, submessage_arena);
    }
    
  } else {
    
  }
  revision_ = revision;
  // @@protoc_insertion_point(field_set_allocated:Messages.UIndices.revision)
}

// uint64 offset = 9;
inline void UIndices::clear_offset() {
  offset_ = uint64_t{0u};
}
inline uint64_t UIndices::_internal_offset() const {
  return offset_;
}
inline uint64_t UIndices::offset() const {
  // @@protoc_insertion_point(field_get:Messages.UIndices.offset)
  return _internal_offset();
}
inline void UIndices::_internal_set_offset(uint64_t value) {
  
  offset_ = value;
}
inline void UIndices::set_offset(uint64_t value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:Messages.UIndices.offset)
}

// repeated uint32 values = 10 [packed = true];
inline int UIndices::_internal_values_size() const {
  return values_.size();
}
inline int UIndices::values_size() const {
  return _internal_values_size();
}
inline void UIndices::clear_values() {
  values_.Clear();
}
inline uint32_t UIndices::_internal_values(int index) const {
  return values_.Get(index);
}
inline uint32_t UIndices::values(int index) const {
  // @@protoc_insertion_point(field_get:Messages.UIndices.values)
  return _internal_values(index);
}
inline void UIndices::set_values(int index, uint32_t value) {
  values_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.UIndices.values)
}
inline void UIndices::_internal_add_values(uint32_t value) {
  values_.Add(value);
}
inline void UIndices::add_values(uint32_t value) {
  _internal_add_values(value);
  // @@protoc_insertion_point(field_add:Messages.UIndices.values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
UIndices::_internal_values() const {
  return values_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
UIndices::values() const {
  // @@protoc_insertion_point(field_list:Messages.UIndices.values)
  return _internal_values();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
UIndices::_internal_mutable_values() {
  return &values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
UIndices::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:Messages.UIndices.values)
  return _internal_mutable_values();
}

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

// Elements

// repeated uint32 element_indices = 1 [packed = true];
inline int Elements::_internal_element_indices_size() const {
  return element_indices_.size();
}
inline int Elements::element_indices_size() const {
  return _internal_element_indices_size();
}
inline void Elements::clear_element_indices() {
  element_indices_.Clear();
}
inline uint32_t Elements::_internal_element_indices(int index) const {
  return element_indices_.Get(index);
}
inline uint32_t Elements::element_indices(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Elements.element_indices)
  return _internal_element_indices(index);
}
inline void Elements::set_element_indices(int index, uint32_t value) {
  element_indices_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Elements.element_indices)
}
inline void Elements::_internal_add_element_indices(uint32_t value) {
  element_indices_.Add(value);
}
inline void Elements::add_element_indices(uint32_t value) {
  _internal_add_element_indices(value);
  // @@protoc_insertion_point(field_add:Messages.Elements.element_indices)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Elements::_internal_element_indices() const {
  return element_indices_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Elements::element_indices() const {
  // @@protoc_insertion_point(field_list:Messages.Elements.element_indices)
  return _internal_element_indices();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Elements::_internal_mutable_element_indices() {
  return &element_indices_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Elements::mutable_element_indices() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Elements.element_indices)
  return _internal_mutable_element_indices();
}

// repeated uint32 element_types = 2 [packed = true];
inline int Elements::_internal_element_types_size() const {
  return element_types_.size();
}
inline int Elements::element_types_size() const {
  return _internal_element_types_size();
}
inline void Elements::clear_element_types() {
  element_types_.Clear();
}
inline uint32_t Elements::_internal_element_types(int index) const {
  return element_types_.Get(index);
}
inline uint32_t Elements::element_types(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Elements.element_types)
  return _internal_element_types(index);
}
inline void Elements::set_element_types(int index, uint32_t value) {
  element_types_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Elements.element_types)
}
inline void Elements::_internal_add_element_types(uint32_t value) {
  element_types_.Add(value);
}
inline void Elements::add_element_types(uint32_t value) {
  _internal_add_element_types(value);
  // @@protoc_insertion_point(field_add:Messages.Elements.element_types)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Elements::_internal_element_types() const {
  return element_types_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Elements::element_types() const {
  // @@protoc_insertion_point(field_list:Messages.Elements.element_types)
  return _internal_element_types();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Elements::_internal_mutable_element_types() {
  return &element_types_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Elements::mutable_element_types() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Elements.element_types)
  return _internal_mutable_element_types();
}

// repeated int32 element_ids = 3 [packed = true];
inline int Elements::_internal_element_ids_size() const {
  return element_ids_.size();
}
inline int Elements::element_ids_size() const {
  return _internal_element_ids_size();
}
inline void Elements::clear_element_ids() {
  element_ids_.Clear();
}
inline int32_t Elements::_internal_element_ids(int index) const {
  return element_ids_.Get(index);
}
inline int32_t Elements::element_ids(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Elements.element_ids)
  return _internal_element_ids(index);
}
inline void Elements::set_element_ids(int index, int32_t value) {
  element_ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Elements.element_ids)
}
inline void Elements::_internal_add_element_ids(int32_t value) {
  element_ids_.Add(value);
}
inline void Elements::add_element_ids(int32_t value) {
  _internal_add_element_ids(value);
  // @@protoc_insertion_point(field_add:Messages.Elements.element_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
Elements::_internal_element_ids() const {
  return element_ids_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
Elements::element_ids() const {
  // @@protoc_insertion_point(field_list:Messages.Elements.element_ids)
  return _internal_element_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
Elements::_internal_mutable_element_ids() {
  return &element_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
Elements::mutable_element_ids() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Elements.element_ids)
  return _internal_mutable_element_ids();
}

// repeated uint32 node_indices = 4 [packed = true];
inline int Elements::_internal_node_indices_size() const {
  return node_indices_.size();
}
inline int Elements::node_indices_size() const {
  return _internal_node_indices_size();
}
inline void Elements::clear_node_indices() {
  node_indices_.Clear();
}
inline uint32_t Elements::_internal_node_indices(int index) const {
  return node_indices_.Get(index);
}
inline uint32_t Elements::node_indices(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Elements.node_indices)
  return _internal_node_indices(index);
}
inline void Elements::set_node_indices(int index, uint32_t value) {
  node_indices_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Elements.node_indices)
}
inline void Elements::_internal_add_node_indices(uint32_t value) {
  node_indices_.Add(value);
}
inline void Elements::add_node_indices(uint32_t value) {
  _internal_add_node_indices(value);
  // @@protoc_insertion_point(field_add:Messages.Elements.node_indices)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Elements::_internal_node_indices() const {
  return node_indices_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Elements::node_indices() const {
  // @@protoc_insertion_point(field_list:Messages.Elements.node_indices)
  return _internal_node_indices();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Elements::_internal_mutable_node_indices() {
  return &node_indices_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Elements::mutable_node_indices() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Elements.node_indices)
  return _internal_mutable_node_indices();
}

// repeated double element_centers = 10 [packed = true];
inline int Elements::_internal_element_centers_size() const {
  return element_centers_.size();
}
inline int Elements::element_centers_size() const {
  return _internal_element_centers_size();
}
inline void Elements::clear_element_centers() {
  element_centers_.Clear();
}
inline double Elements::_internal_element_centers(int index) const {
  return element_centers_.Get(index);
}
inline double Elements::element_centers(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Elements.element_centers)
  return _internal_element_centers(index);
}
inline void Elements::set_element_centers(int index, double value) {
  element_centers_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Elements.element_centers)
}
inline void Elements::_internal_add_element_centers(double value) {
  element_centers_.Add(value);
}
inline void Elements::add_element_centers(double value) {
  _internal_add_element_centers(value);
  // @@protoc_insertion_point(field_add:Messages.Elements.element_centers)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Elements::_internal_element_centers() const {
  return element_centers_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Elements::element_centers() const {
  // @@protoc_insertion_point(field_list:Messages.Elements.element_centers)
  return _internal_element_centers();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Elements::_internal_mutable_element_centers() {
  return &element_centers_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Elements::mutable_element_centers() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Elements.element_centers)
  return _internal_mutable_element_centers();
}

// repeated double element_measures = 11 [packed = true];
inline int Elements::_internal_element_measures_size() const {
  return element_measures_.size();
}
inline int Elements::element_measures_size() const {
  return _internal_element_measures_size();
}
inline void Elements::clear_element_measures() {
  element_measures_.Clear();
}
inline double Elements::_internal_element_measures(int index) const {
  return element_measures_.Get(index);
}
inline double Elements::element_measures(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Elements.element_measures)
  return _internal_element_measures(index);
}
inline void Elements::set_element_measures(int index, double value) {
  element_measures_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Elements.element_measures)
}
inline void Elements::_internal_add_element_measures(double value) {
  element_measures_.Add(value);
}
inline void Elements::add_element_measures(double value) {
  _internal_add_element_measures(value);
  // @@protoc_insertion_point(field_add:Messages.Elements.element_measures)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Elements::_internal_element_measures() const {
  return element_measures_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Elements::element_measures() const {
  // @@protoc_insertion_point(field_list:Messages.Elements.element_measures)
  return _internal_element_measures();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Elements::_internal_mutable_element_measures() {
  return &element_measures_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Elements::mutable_element_measures() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Elements.element_measures)
  return _internal_mutable_element_measures();
}

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace Messages

// @@protoc_insertion_point(global_scope)

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