osmformat.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_osmformat_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_osmformat_2eproto

#include <limits>
#include <string>

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

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

// Internal implementation detail -- do not use these members.
struct TableStruct_osmformat_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_osmformat_2eproto;
namespace OSMPBF {
class ChangeSet;
struct ChangeSetDefaultTypeInternal;
extern ChangeSetDefaultTypeInternal _ChangeSet_default_instance_;
class DenseInfo;
struct DenseInfoDefaultTypeInternal;
extern DenseInfoDefaultTypeInternal _DenseInfo_default_instance_;
class DenseNodes;
struct DenseNodesDefaultTypeInternal;
extern DenseNodesDefaultTypeInternal _DenseNodes_default_instance_;
class HeaderBBox;
struct HeaderBBoxDefaultTypeInternal;
extern HeaderBBoxDefaultTypeInternal _HeaderBBox_default_instance_;
class HeaderBlock;
struct HeaderBlockDefaultTypeInternal;
extern HeaderBlockDefaultTypeInternal _HeaderBlock_default_instance_;
class Info;
struct InfoDefaultTypeInternal;
extern InfoDefaultTypeInternal _Info_default_instance_;
class Node;
struct NodeDefaultTypeInternal;
extern NodeDefaultTypeInternal _Node_default_instance_;
class PrimitiveBlock;
struct PrimitiveBlockDefaultTypeInternal;
extern PrimitiveBlockDefaultTypeInternal _PrimitiveBlock_default_instance_;
class PrimitiveGroup;
struct PrimitiveGroupDefaultTypeInternal;
extern PrimitiveGroupDefaultTypeInternal _PrimitiveGroup_default_instance_;
class Relation;
struct RelationDefaultTypeInternal;
extern RelationDefaultTypeInternal _Relation_default_instance_;
class StringTable;
struct StringTableDefaultTypeInternal;
extern StringTableDefaultTypeInternal _StringTable_default_instance_;
class Way;
struct WayDefaultTypeInternal;
extern WayDefaultTypeInternal _Way_default_instance_;
}  // namespace OSMPBF
PROTOBUF_NAMESPACE_OPEN
template<> ::OSMPBF::ChangeSet* Arena::CreateMaybeMessage<::OSMPBF::ChangeSet>(Arena*);
template<> ::OSMPBF::DenseInfo* Arena::CreateMaybeMessage<::OSMPBF::DenseInfo>(Arena*);
template<> ::OSMPBF::DenseNodes* Arena::CreateMaybeMessage<::OSMPBF::DenseNodes>(Arena*);
template<> ::OSMPBF::HeaderBBox* Arena::CreateMaybeMessage<::OSMPBF::HeaderBBox>(Arena*);
template<> ::OSMPBF::HeaderBlock* Arena::CreateMaybeMessage<::OSMPBF::HeaderBlock>(Arena*);
template<> ::OSMPBF::Info* Arena::CreateMaybeMessage<::OSMPBF::Info>(Arena*);
template<> ::OSMPBF::Node* Arena::CreateMaybeMessage<::OSMPBF::Node>(Arena*);
template<> ::OSMPBF::PrimitiveBlock* Arena::CreateMaybeMessage<::OSMPBF::PrimitiveBlock>(Arena*);
template<> ::OSMPBF::PrimitiveGroup* Arena::CreateMaybeMessage<::OSMPBF::PrimitiveGroup>(Arena*);
template<> ::OSMPBF::Relation* Arena::CreateMaybeMessage<::OSMPBF::Relation>(Arena*);
template<> ::OSMPBF::StringTable* Arena::CreateMaybeMessage<::OSMPBF::StringTable>(Arena*);
template<> ::OSMPBF::Way* Arena::CreateMaybeMessage<::OSMPBF::Way>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace OSMPBF {

enum Relation_MemberType : int {
  Relation_MemberType_NODE = 0,
  Relation_MemberType_WAY = 1,
  Relation_MemberType_RELATION = 2
};
bool Relation_MemberType_IsValid(int value);
constexpr Relation_MemberType Relation_MemberType_MemberType_MIN = Relation_MemberType_NODE;
constexpr Relation_MemberType Relation_MemberType_MemberType_MAX = Relation_MemberType_RELATION;
constexpr int Relation_MemberType_MemberType_ARRAYSIZE = Relation_MemberType_MemberType_MAX + 1;

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

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

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

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HeaderBlock* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OSMPBF.HeaderBlock";
  }
  protected:
  explicit HeaderBlock(::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 {
    kRequiredFeaturesFieldNumber = 4,
    kOptionalFeaturesFieldNumber = 5,
    kWritingprogramFieldNumber = 16,
    kSourceFieldNumber = 17,
    kOsmosisReplicationBaseUrlFieldNumber = 34,
    kBboxFieldNumber = 1,
    kOsmosisReplicationTimestampFieldNumber = 32,
    kOsmosisReplicationSequenceNumberFieldNumber = 33,
  };
  // repeated string required_features = 4;
  int required_features_size() const;
  private:
  int _internal_required_features_size() const;
  public:
  void clear_required_features();
  const std::string& required_features(int index) const;
  std::string* mutable_required_features(int index);
  void set_required_features(int index, const std::string& value);
  void set_required_features(int index, std::string&& value);
  void set_required_features(int index, const char* value);
  void set_required_features(int index, const char* value, size_t size);
  std::string* add_required_features();
  void add_required_features(const std::string& value);
  void add_required_features(std::string&& value);
  void add_required_features(const char* value);
  void add_required_features(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& required_features() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_required_features();
  private:
  const std::string& _internal_required_features(int index) const;
  std::string* _internal_add_required_features();
  public:

  // repeated string optional_features = 5;
  int optional_features_size() const;
  private:
  int _internal_optional_features_size() const;
  public:
  void clear_optional_features();
  const std::string& optional_features(int index) const;
  std::string* mutable_optional_features(int index);
  void set_optional_features(int index, const std::string& value);
  void set_optional_features(int index, std::string&& value);
  void set_optional_features(int index, const char* value);
  void set_optional_features(int index, const char* value, size_t size);
  std::string* add_optional_features();
  void add_optional_features(const std::string& value);
  void add_optional_features(std::string&& value);
  void add_optional_features(const char* value);
  void add_optional_features(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& optional_features() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_optional_features();
  private:
  const std::string& _internal_optional_features(int index) const;
  std::string* _internal_add_optional_features();
  public:

  // optional string writingprogram = 16;
  bool has_writingprogram() const;
  private:
  bool _internal_has_writingprogram() const;
  public:
  void clear_writingprogram();
  const std::string& writingprogram() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_writingprogram(ArgT0&& arg0, ArgT... args);
  std::string* mutable_writingprogram();
  PROTOBUF_NODISCARD std::string* release_writingprogram();
  void set_allocated_writingprogram(std::string* writingprogram);
  private:
  const std::string& _internal_writingprogram() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_writingprogram(const std::string& value);
  std::string* _internal_mutable_writingprogram();
  public:

  // optional string source = 17;
  bool has_source() const;
  private:
  bool _internal_has_source() const;
  public:
  void clear_source();
  const std::string& source() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_source(ArgT0&& arg0, ArgT... args);
  std::string* mutable_source();
  PROTOBUF_NODISCARD std::string* release_source();
  void set_allocated_source(std::string* source);
  private:
  const std::string& _internal_source() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_source(const std::string& value);
  std::string* _internal_mutable_source();
  public:

  // optional string osmosis_replication_base_url = 34;
  bool has_osmosis_replication_base_url() const;
  private:
  bool _internal_has_osmosis_replication_base_url() const;
  public:
  void clear_osmosis_replication_base_url();
  const std::string& osmosis_replication_base_url() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_osmosis_replication_base_url(ArgT0&& arg0, ArgT... args);
  std::string* mutable_osmosis_replication_base_url();
  PROTOBUF_NODISCARD std::string* release_osmosis_replication_base_url();
  void set_allocated_osmosis_replication_base_url(std::string* osmosis_replication_base_url);
  private:
  const std::string& _internal_osmosis_replication_base_url() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_osmosis_replication_base_url(const std::string& value);
  std::string* _internal_mutable_osmosis_replication_base_url();
  public:

  // optional .OSMPBF.HeaderBBox bbox = 1;
  bool has_bbox() const;
  private:
  bool _internal_has_bbox() const;
  public:
  void clear_bbox();
  const ::OSMPBF::HeaderBBox& bbox() const;
  PROTOBUF_NODISCARD ::OSMPBF::HeaderBBox* release_bbox();
  ::OSMPBF::HeaderBBox* mutable_bbox();
  void set_allocated_bbox(::OSMPBF::HeaderBBox* bbox);
  private:
  const ::OSMPBF::HeaderBBox& _internal_bbox() const;
  ::OSMPBF::HeaderBBox* _internal_mutable_bbox();
  public:
  void unsafe_arena_set_allocated_bbox(
      ::OSMPBF::HeaderBBox* bbox);
  ::OSMPBF::HeaderBBox* unsafe_arena_release_bbox();

  // optional int64 osmosis_replication_timestamp = 32;
  bool has_osmosis_replication_timestamp() const;
  private:
  bool _internal_has_osmosis_replication_timestamp() const;
  public:
  void clear_osmosis_replication_timestamp();
  int64_t osmosis_replication_timestamp() const;
  void set_osmosis_replication_timestamp(int64_t value);
  private:
  int64_t _internal_osmosis_replication_timestamp() const;
  void _internal_set_osmosis_replication_timestamp(int64_t value);
  public:

  // optional int64 osmosis_replication_sequence_number = 33;
  bool has_osmosis_replication_sequence_number() const;
  private:
  bool _internal_has_osmosis_replication_sequence_number() const;
  public:
  void clear_osmosis_replication_sequence_number();
  int64_t osmosis_replication_sequence_number() const;
  void set_osmosis_replication_sequence_number(int64_t value);
  private:
  int64_t _internal_osmosis_replication_sequence_number() const;
  void _internal_set_osmosis_replication_sequence_number(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:OSMPBF.HeaderBlock)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> required_features_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> optional_features_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr writingprogram_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr osmosis_replication_base_url_;
    ::OSMPBF::HeaderBBox* bbox_;
    int64_t osmosis_replication_timestamp_;
    int64_t osmosis_replication_sequence_number_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_osmformat_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

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

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(HeaderBBox* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OSMPBF.HeaderBBox";
  }
  protected:
  explicit HeaderBBox(::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 {
    kLeftFieldNumber = 1,
    kRightFieldNumber = 2,
    kTopFieldNumber = 3,
    kBottomFieldNumber = 4,
  };
  // required sint64 left = 1;
  bool has_left() const;
  private:
  bool _internal_has_left() const;
  public:
  void clear_left();
  int64_t left() const;
  void set_left(int64_t value);
  private:
  int64_t _internal_left() const;
  void _internal_set_left(int64_t value);
  public:

  // required sint64 right = 2;
  bool has_right() const;
  private:
  bool _internal_has_right() const;
  public:
  void clear_right();
  int64_t right() const;
  void set_right(int64_t value);
  private:
  int64_t _internal_right() const;
  void _internal_set_right(int64_t value);
  public:

  // required sint64 top = 3;
  bool has_top() const;
  private:
  bool _internal_has_top() const;
  public:
  void clear_top();
  int64_t top() const;
  void set_top(int64_t value);
  private:
  int64_t _internal_top() const;
  void _internal_set_top(int64_t value);
  public:

  // required sint64 bottom = 4;
  bool has_bottom() const;
  private:
  bool _internal_has_bottom() const;
  public:
  void clear_bottom();
  int64_t bottom() const;
  void set_bottom(int64_t value);
  private:
  int64_t _internal_bottom() const;
  void _internal_set_bottom(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:OSMPBF.HeaderBBox)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int64_t left_;
    int64_t right_;
    int64_t top_;
    int64_t bottom_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_osmformat_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

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

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PrimitiveBlock* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OSMPBF.PrimitiveBlock";
  }
  protected:
  explicit PrimitiveBlock(::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 {
    kPrimitivegroupFieldNumber = 2,
    kStringtableFieldNumber = 1,
    kLatOffsetFieldNumber = 19,
    kLonOffsetFieldNumber = 20,
    kGranularityFieldNumber = 17,
    kDateGranularityFieldNumber = 18,
  };
  // repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;
  int primitivegroup_size() const;
  private:
  int _internal_primitivegroup_size() const;
  public:
  void clear_primitivegroup();
  ::OSMPBF::PrimitiveGroup* mutable_primitivegroup(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::PrimitiveGroup >*
      mutable_primitivegroup();
  private:
  const ::OSMPBF::PrimitiveGroup& _internal_primitivegroup(int index) const;
  ::OSMPBF::PrimitiveGroup* _internal_add_primitivegroup();
  public:
  const ::OSMPBF::PrimitiveGroup& primitivegroup(int index) const;
  ::OSMPBF::PrimitiveGroup* add_primitivegroup();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::PrimitiveGroup >&
      primitivegroup() const;

  // required .OSMPBF.StringTable stringtable = 1;
  bool has_stringtable() const;
  private:
  bool _internal_has_stringtable() const;
  public:
  void clear_stringtable();
  const ::OSMPBF::StringTable& stringtable() const;
  PROTOBUF_NODISCARD ::OSMPBF::StringTable* release_stringtable();
  ::OSMPBF::StringTable* mutable_stringtable();
  void set_allocated_stringtable(::OSMPBF::StringTable* stringtable);
  private:
  const ::OSMPBF::StringTable& _internal_stringtable() const;
  ::OSMPBF::StringTable* _internal_mutable_stringtable();
  public:
  void unsafe_arena_set_allocated_stringtable(
      ::OSMPBF::StringTable* stringtable);
  ::OSMPBF::StringTable* unsafe_arena_release_stringtable();

  // optional int64 lat_offset = 19 [default = 0];
  bool has_lat_offset() const;
  private:
  bool _internal_has_lat_offset() const;
  public:
  void clear_lat_offset();
  int64_t lat_offset() const;
  void set_lat_offset(int64_t value);
  private:
  int64_t _internal_lat_offset() const;
  void _internal_set_lat_offset(int64_t value);
  public:

  // optional int64 lon_offset = 20 [default = 0];
  bool has_lon_offset() const;
  private:
  bool _internal_has_lon_offset() const;
  public:
  void clear_lon_offset();
  int64_t lon_offset() const;
  void set_lon_offset(int64_t value);
  private:
  int64_t _internal_lon_offset() const;
  void _internal_set_lon_offset(int64_t value);
  public:

  // optional int32 granularity = 17 [default = 100];
  bool has_granularity() const;
  private:
  bool _internal_has_granularity() const;
  public:
  void clear_granularity();
  int32_t granularity() const;
  void set_granularity(int32_t value);
  private:
  int32_t _internal_granularity() const;
  void _internal_set_granularity(int32_t value);
  public:

  // optional int32 date_granularity = 18 [default = 1000];
  bool has_date_granularity() const;
  private:
  bool _internal_has_date_granularity() const;
  public:
  void clear_date_granularity();
  int32_t date_granularity() const;
  void set_date_granularity(int32_t value);
  private:
  int32_t _internal_date_granularity() const;
  void _internal_set_date_granularity(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:OSMPBF.PrimitiveBlock)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::PrimitiveGroup > primitivegroup_;
    ::OSMPBF::StringTable* stringtable_;
    int64_t lat_offset_;
    int64_t lon_offset_;
    int32_t granularity_;
    int32_t date_granularity_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_osmformat_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

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

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PrimitiveGroup* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OSMPBF.PrimitiveGroup";
  }
  protected:
  explicit PrimitiveGroup(::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 {
    kNodesFieldNumber = 1,
    kWaysFieldNumber = 3,
    kRelationsFieldNumber = 4,
    kChangesetsFieldNumber = 5,
    kDenseFieldNumber = 2,
  };
  // repeated .OSMPBF.Node nodes = 1;
  int nodes_size() const;
  private:
  int _internal_nodes_size() const;
  public:
  void clear_nodes();
  ::OSMPBF::Node* mutable_nodes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::Node >*
      mutable_nodes();
  private:
  const ::OSMPBF::Node& _internal_nodes(int index) const;
  ::OSMPBF::Node* _internal_add_nodes();
  public:
  const ::OSMPBF::Node& nodes(int index) const;
  ::OSMPBF::Node* add_nodes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::Node >&
      nodes() const;

  // repeated .OSMPBF.Way ways = 3;
  int ways_size() const;
  private:
  int _internal_ways_size() const;
  public:
  void clear_ways();
  ::OSMPBF::Way* mutable_ways(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::Way >*
      mutable_ways();
  private:
  const ::OSMPBF::Way& _internal_ways(int index) const;
  ::OSMPBF::Way* _internal_add_ways();
  public:
  const ::OSMPBF::Way& ways(int index) const;
  ::OSMPBF::Way* add_ways();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::Way >&
      ways() const;

  // repeated .OSMPBF.Relation relations = 4;
  int relations_size() const;
  private:
  int _internal_relations_size() const;
  public:
  void clear_relations();
  ::OSMPBF::Relation* mutable_relations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::Relation >*
      mutable_relations();
  private:
  const ::OSMPBF::Relation& _internal_relations(int index) const;
  ::OSMPBF::Relation* _internal_add_relations();
  public:
  const ::OSMPBF::Relation& relations(int index) const;
  ::OSMPBF::Relation* add_relations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::Relation >&
      relations() const;

  // repeated .OSMPBF.ChangeSet changesets = 5;
  int changesets_size() const;
  private:
  int _internal_changesets_size() const;
  public:
  void clear_changesets();
  ::OSMPBF::ChangeSet* mutable_changesets(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::ChangeSet >*
      mutable_changesets();
  private:
  const ::OSMPBF::ChangeSet& _internal_changesets(int index) const;
  ::OSMPBF::ChangeSet* _internal_add_changesets();
  public:
  const ::OSMPBF::ChangeSet& changesets(int index) const;
  ::OSMPBF::ChangeSet* add_changesets();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::ChangeSet >&
      changesets() const;

  // optional .OSMPBF.DenseNodes dense = 2;
  bool has_dense() const;
  private:
  bool _internal_has_dense() const;
  public:
  void clear_dense();
  const ::OSMPBF::DenseNodes& dense() const;
  PROTOBUF_NODISCARD ::OSMPBF::DenseNodes* release_dense();
  ::OSMPBF::DenseNodes* mutable_dense();
  void set_allocated_dense(::OSMPBF::DenseNodes* dense);
  private:
  const ::OSMPBF::DenseNodes& _internal_dense() const;
  ::OSMPBF::DenseNodes* _internal_mutable_dense();
  public:
  void unsafe_arena_set_allocated_dense(
      ::OSMPBF::DenseNodes* dense);
  ::OSMPBF::DenseNodes* unsafe_arena_release_dense();

  // @@protoc_insertion_point(class_scope:OSMPBF.PrimitiveGroup)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::Node > nodes_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::Way > ways_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::Relation > relations_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::ChangeSet > changesets_;
    ::OSMPBF::DenseNodes* dense_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_osmformat_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

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

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StringTable* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OSMPBF.StringTable";
  }
  protected:
  explicit StringTable(::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 {
    kSFieldNumber = 1,
  };
  // repeated bytes s = 1;
  int s_size() const;
  private:
  int _internal_s_size() const;
  public:
  void clear_s();
  const std::string& s(int index) const;
  std::string* mutable_s(int index);
  void set_s(int index, const std::string& value);
  void set_s(int index, std::string&& value);
  void set_s(int index, const char* value);
  void set_s(int index, const void* value, size_t size);
  std::string* add_s();
  void add_s(const std::string& value);
  void add_s(std::string&& value);
  void add_s(const char* value);
  void add_s(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& s() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_s();
  private:
  const std::string& _internal_s(int index) const;
  std::string* _internal_add_s();
  public:

  // @@protoc_insertion_point(class_scope:OSMPBF.StringTable)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> s_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_osmformat_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

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

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Info* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OSMPBF.Info";
  }
  protected:
  explicit Info(::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 {
    kTimestampFieldNumber = 2,
    kChangesetFieldNumber = 3,
    kUidFieldNumber = 4,
    kUserSidFieldNumber = 5,
    kVisibleFieldNumber = 6,
    kVersionFieldNumber = 1,
  };
  // optional int64 timestamp = 2;
  bool has_timestamp() const;
  private:
  bool _internal_has_timestamp() const;
  public:
  void clear_timestamp();
  int64_t timestamp() const;
  void set_timestamp(int64_t value);
  private:
  int64_t _internal_timestamp() const;
  void _internal_set_timestamp(int64_t value);
  public:

  // optional int64 changeset = 3;
  bool has_changeset() const;
  private:
  bool _internal_has_changeset() const;
  public:
  void clear_changeset();
  int64_t changeset() const;
  void set_changeset(int64_t value);
  private:
  int64_t _internal_changeset() const;
  void _internal_set_changeset(int64_t value);
  public:

  // optional int32 uid = 4;
  bool has_uid() const;
  private:
  bool _internal_has_uid() const;
  public:
  void clear_uid();
  int32_t uid() const;
  void set_uid(int32_t value);
  private:
  int32_t _internal_uid() const;
  void _internal_set_uid(int32_t value);
  public:

  // optional uint32 user_sid = 5;
  bool has_user_sid() const;
  private:
  bool _internal_has_user_sid() const;
  public:
  void clear_user_sid();
  uint32_t user_sid() const;
  void set_user_sid(uint32_t value);
  private:
  uint32_t _internal_user_sid() const;
  void _internal_set_user_sid(uint32_t value);
  public:

  // optional bool visible = 6;
  bool has_visible() const;
  private:
  bool _internal_has_visible() const;
  public:
  void clear_visible();
  bool visible() const;
  void set_visible(bool value);
  private:
  bool _internal_visible() const;
  void _internal_set_visible(bool value);
  public:

  // optional int32 version = 1 [default = -1];
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  int32_t version() const;
  void set_version(int32_t value);
  private:
  int32_t _internal_version() const;
  void _internal_set_version(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:OSMPBF.Info)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int64_t timestamp_;
    int64_t changeset_;
    int32_t uid_;
    uint32_t user_sid_;
    bool visible_;
    int32_t version_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_osmformat_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

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

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DenseInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OSMPBF.DenseInfo";
  }
  protected:
  explicit DenseInfo(::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 {
    kVersionFieldNumber = 1,
    kTimestampFieldNumber = 2,
    kChangesetFieldNumber = 3,
    kUidFieldNumber = 4,
    kUserSidFieldNumber = 5,
    kVisibleFieldNumber = 6,
  };
  // repeated int32 version = 1 [packed = true];
  int version_size() const;
  private:
  int _internal_version_size() const;
  public:
  void clear_version();
  private:
  int32_t _internal_version(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_version() const;
  void _internal_add_version(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_version();
  public:
  int32_t version(int index) const;
  void set_version(int index, int32_t value);
  void add_version(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      version() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_version();

  // repeated sint64 timestamp = 2 [packed = true];
  int timestamp_size() const;
  private:
  int _internal_timestamp_size() const;
  public:
  void clear_timestamp();
  private:
  int64_t _internal_timestamp(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_timestamp() const;
  void _internal_add_timestamp(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_timestamp();
  public:
  int64_t timestamp(int index) const;
  void set_timestamp(int index, int64_t value);
  void add_timestamp(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      timestamp() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_timestamp();

  // repeated sint64 changeset = 3 [packed = true];
  int changeset_size() const;
  private:
  int _internal_changeset_size() const;
  public:
  void clear_changeset();
  private:
  int64_t _internal_changeset(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_changeset() const;
  void _internal_add_changeset(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_changeset();
  public:
  int64_t changeset(int index) const;
  void set_changeset(int index, int64_t value);
  void add_changeset(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      changeset() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_changeset();

  // repeated sint32 uid = 4 [packed = true];
  int uid_size() const;
  private:
  int _internal_uid_size() const;
  public:
  void clear_uid();
  private:
  int32_t _internal_uid(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_uid() const;
  void _internal_add_uid(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_uid();
  public:
  int32_t uid(int index) const;
  void set_uid(int index, int32_t value);
  void add_uid(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      uid() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_uid();

  // repeated sint32 user_sid = 5 [packed = true];
  int user_sid_size() const;
  private:
  int _internal_user_sid_size() const;
  public:
  void clear_user_sid();
  private:
  int32_t _internal_user_sid(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_user_sid() const;
  void _internal_add_user_sid(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_user_sid();
  public:
  int32_t user_sid(int index) const;
  void set_user_sid(int index, int32_t value);
  void add_user_sid(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      user_sid() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_user_sid();

  // repeated bool visible = 6 [packed = true];
  int visible_size() const;
  private:
  int _internal_visible_size() const;
  public:
  void clear_visible();
  private:
  bool _internal_visible(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      _internal_visible() const;
  void _internal_add_visible(bool value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      _internal_mutable_visible();
  public:
  bool visible(int index) const;
  void set_visible(int index, bool value);
  void add_visible(bool value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      visible() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      mutable_visible();

  // @@protoc_insertion_point(class_scope:OSMPBF.DenseInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > version_;
    mutable std::atomic<int> _version_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > timestamp_;
    mutable std::atomic<int> _timestamp_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > changeset_;
    mutable std::atomic<int> _changeset_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > uid_;
    mutable std::atomic<int> _uid_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > user_sid_;
    mutable std::atomic<int> _user_sid_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > visible_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_osmformat_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

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

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ChangeSet* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OSMPBF.ChangeSet";
  }
  protected:
  explicit ChangeSet(::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 {
    kIdFieldNumber = 1,
  };
  // required int64 id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  int64_t id() const;
  void set_id(int64_t value);
  private:
  int64_t _internal_id() const;
  void _internal_set_id(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:OSMPBF.ChangeSet)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int64_t id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_osmformat_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

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

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Node* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OSMPBF.Node";
  }
  protected:
  explicit Node(::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 {
    kKeysFieldNumber = 2,
    kValsFieldNumber = 3,
    kInfoFieldNumber = 4,
    kIdFieldNumber = 1,
    kLatFieldNumber = 8,
    kLonFieldNumber = 9,
  };
  // repeated uint32 keys = 2 [packed = true];
  int keys_size() const;
  private:
  int _internal_keys_size() const;
  public:
  void clear_keys();
  private:
  uint32_t _internal_keys(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_keys() const;
  void _internal_add_keys(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_keys();
  public:
  uint32_t keys(int index) const;
  void set_keys(int index, uint32_t value);
  void add_keys(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      keys() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_keys();

  // repeated uint32 vals = 3 [packed = true];
  int vals_size() const;
  private:
  int _internal_vals_size() const;
  public:
  void clear_vals();
  private:
  uint32_t _internal_vals(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_vals() const;
  void _internal_add_vals(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_vals();
  public:
  uint32_t vals(int index) const;
  void set_vals(int index, uint32_t value);
  void add_vals(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      vals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_vals();

  // optional .OSMPBF.Info info = 4;
  bool has_info() const;
  private:
  bool _internal_has_info() const;
  public:
  void clear_info();
  const ::OSMPBF::Info& info() const;
  PROTOBUF_NODISCARD ::OSMPBF::Info* release_info();
  ::OSMPBF::Info* mutable_info();
  void set_allocated_info(::OSMPBF::Info* info);
  private:
  const ::OSMPBF::Info& _internal_info() const;
  ::OSMPBF::Info* _internal_mutable_info();
  public:
  void unsafe_arena_set_allocated_info(
      ::OSMPBF::Info* info);
  ::OSMPBF::Info* unsafe_arena_release_info();

  // required sint64 id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  int64_t id() const;
  void set_id(int64_t value);
  private:
  int64_t _internal_id() const;
  void _internal_set_id(int64_t value);
  public:

  // required sint64 lat = 8;
  bool has_lat() const;
  private:
  bool _internal_has_lat() const;
  public:
  void clear_lat();
  int64_t lat() const;
  void set_lat(int64_t value);
  private:
  int64_t _internal_lat() const;
  void _internal_set_lat(int64_t value);
  public:

  // required sint64 lon = 9;
  bool has_lon() const;
  private:
  bool _internal_has_lon() const;
  public:
  void clear_lon();
  int64_t lon() const;
  void set_lon(int64_t value);
  private:
  int64_t _internal_lon() const;
  void _internal_set_lon(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:OSMPBF.Node)
 private:
  class _Internal;

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > keys_;
    mutable std::atomic<int> _keys_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > vals_;
    mutable std::atomic<int> _vals_cached_byte_size_;
    ::OSMPBF::Info* info_;
    int64_t id_;
    int64_t lat_;
    int64_t lon_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_osmformat_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

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

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DenseNodes* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OSMPBF.DenseNodes";
  }
  protected:
  explicit DenseNodes(::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 {
    kIdFieldNumber = 1,
    kLatFieldNumber = 8,
    kLonFieldNumber = 9,
    kKeysValsFieldNumber = 10,
    kDenseinfoFieldNumber = 5,
  };
  // repeated sint64 id = 1 [packed = true];
  int id_size() const;
  private:
  int _internal_id_size() const;
  public:
  void clear_id();
  private:
  int64_t _internal_id(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_id() const;
  void _internal_add_id(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_id();
  public:
  int64_t id(int index) const;
  void set_id(int index, int64_t value);
  void add_id(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      id() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_id();

  // repeated sint64 lat = 8 [packed = true];
  int lat_size() const;
  private:
  int _internal_lat_size() const;
  public:
  void clear_lat();
  private:
  int64_t _internal_lat(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_lat() const;
  void _internal_add_lat(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_lat();
  public:
  int64_t lat(int index) const;
  void set_lat(int index, int64_t value);
  void add_lat(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      lat() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_lat();

  // repeated sint64 lon = 9 [packed = true];
  int lon_size() const;
  private:
  int _internal_lon_size() const;
  public:
  void clear_lon();
  private:
  int64_t _internal_lon(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_lon() const;
  void _internal_add_lon(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_lon();
  public:
  int64_t lon(int index) const;
  void set_lon(int index, int64_t value);
  void add_lon(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      lon() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_lon();

  // repeated int32 keys_vals = 10 [packed = true];
  int keys_vals_size() const;
  private:
  int _internal_keys_vals_size() const;
  public:
  void clear_keys_vals();
  private:
  int32_t _internal_keys_vals(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_keys_vals() const;
  void _internal_add_keys_vals(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_keys_vals();
  public:
  int32_t keys_vals(int index) const;
  void set_keys_vals(int index, int32_t value);
  void add_keys_vals(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      keys_vals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_keys_vals();

  // optional .OSMPBF.DenseInfo denseinfo = 5;
  bool has_denseinfo() const;
  private:
  bool _internal_has_denseinfo() const;
  public:
  void clear_denseinfo();
  const ::OSMPBF::DenseInfo& denseinfo() const;
  PROTOBUF_NODISCARD ::OSMPBF::DenseInfo* release_denseinfo();
  ::OSMPBF::DenseInfo* mutable_denseinfo();
  void set_allocated_denseinfo(::OSMPBF::DenseInfo* denseinfo);
  private:
  const ::OSMPBF::DenseInfo& _internal_denseinfo() const;
  ::OSMPBF::DenseInfo* _internal_mutable_denseinfo();
  public:
  void unsafe_arena_set_allocated_denseinfo(
      ::OSMPBF::DenseInfo* denseinfo);
  ::OSMPBF::DenseInfo* unsafe_arena_release_denseinfo();

  // @@protoc_insertion_point(class_scope:OSMPBF.DenseNodes)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > id_;
    mutable std::atomic<int> _id_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > lat_;
    mutable std::atomic<int> _lat_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > lon_;
    mutable std::atomic<int> _lon_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > keys_vals_;
    mutable std::atomic<int> _keys_vals_cached_byte_size_;
    ::OSMPBF::DenseInfo* denseinfo_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_osmformat_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

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

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Way* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OSMPBF.Way";
  }
  protected:
  explicit Way(::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 {
    kKeysFieldNumber = 2,
    kValsFieldNumber = 3,
    kRefsFieldNumber = 8,
    kLatFieldNumber = 9,
    kLonFieldNumber = 10,
    kInfoFieldNumber = 4,
    kIdFieldNumber = 1,
  };
  // repeated uint32 keys = 2 [packed = true];
  int keys_size() const;
  private:
  int _internal_keys_size() const;
  public:
  void clear_keys();
  private:
  uint32_t _internal_keys(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_keys() const;
  void _internal_add_keys(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_keys();
  public:
  uint32_t keys(int index) const;
  void set_keys(int index, uint32_t value);
  void add_keys(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      keys() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_keys();

  // repeated uint32 vals = 3 [packed = true];
  int vals_size() const;
  private:
  int _internal_vals_size() const;
  public:
  void clear_vals();
  private:
  uint32_t _internal_vals(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_vals() const;
  void _internal_add_vals(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_vals();
  public:
  uint32_t vals(int index) const;
  void set_vals(int index, uint32_t value);
  void add_vals(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      vals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_vals();

  // repeated sint64 refs = 8 [packed = true];
  int refs_size() const;
  private:
  int _internal_refs_size() const;
  public:
  void clear_refs();
  private:
  int64_t _internal_refs(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_refs() const;
  void _internal_add_refs(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_refs();
  public:
  int64_t refs(int index) const;
  void set_refs(int index, int64_t value);
  void add_refs(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      refs() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_refs();

  // repeated sint64 lat = 9 [packed = true];
  int lat_size() const;
  private:
  int _internal_lat_size() const;
  public:
  void clear_lat();
  private:
  int64_t _internal_lat(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_lat() const;
  void _internal_add_lat(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_lat();
  public:
  int64_t lat(int index) const;
  void set_lat(int index, int64_t value);
  void add_lat(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      lat() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_lat();

  // repeated sint64 lon = 10 [packed = true];
  int lon_size() const;
  private:
  int _internal_lon_size() const;
  public:
  void clear_lon();
  private:
  int64_t _internal_lon(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_lon() const;
  void _internal_add_lon(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_lon();
  public:
  int64_t lon(int index) const;
  void set_lon(int index, int64_t value);
  void add_lon(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      lon() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_lon();

  // optional .OSMPBF.Info info = 4;
  bool has_info() const;
  private:
  bool _internal_has_info() const;
  public:
  void clear_info();
  const ::OSMPBF::Info& info() const;
  PROTOBUF_NODISCARD ::OSMPBF::Info* release_info();
  ::OSMPBF::Info* mutable_info();
  void set_allocated_info(::OSMPBF::Info* info);
  private:
  const ::OSMPBF::Info& _internal_info() const;
  ::OSMPBF::Info* _internal_mutable_info();
  public:
  void unsafe_arena_set_allocated_info(
      ::OSMPBF::Info* info);
  ::OSMPBF::Info* unsafe_arena_release_info();

  // required int64 id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  int64_t id() const;
  void set_id(int64_t value);
  private:
  int64_t _internal_id() const;
  void _internal_set_id(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:OSMPBF.Way)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > keys_;
    mutable std::atomic<int> _keys_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > vals_;
    mutable std::atomic<int> _vals_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > refs_;
    mutable std::atomic<int> _refs_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > lat_;
    mutable std::atomic<int> _lat_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > lon_;
    mutable std::atomic<int> _lon_cached_byte_size_;
    ::OSMPBF::Info* info_;
    int64_t id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_osmformat_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

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

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Relation* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OSMPBF.Relation";
  }
  protected:
  explicit Relation(::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 ----------------------------------------------------

  typedef Relation_MemberType MemberType;
  static constexpr MemberType NODE =
    Relation_MemberType_NODE;
  static constexpr MemberType WAY =
    Relation_MemberType_WAY;
  static constexpr MemberType RELATION =
    Relation_MemberType_RELATION;
  static inline bool MemberType_IsValid(int value) {
    return Relation_MemberType_IsValid(value);
  }
  static constexpr MemberType MemberType_MIN =
    Relation_MemberType_MemberType_MIN;
  static constexpr MemberType MemberType_MAX =
    Relation_MemberType_MemberType_MAX;
  static constexpr int MemberType_ARRAYSIZE =
    Relation_MemberType_MemberType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  MemberType_descriptor() {
    return Relation_MemberType_descriptor();
  }
  template<typename T>
  static inline const std::string& MemberType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, MemberType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function MemberType_Name.");
    return Relation_MemberType_Name(enum_t_value);
  }
  static inline bool MemberType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      MemberType* value) {
    return Relation_MemberType_Parse(name, value);
  }

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

  enum : int {
    kKeysFieldNumber = 2,
    kValsFieldNumber = 3,
    kRolesSidFieldNumber = 8,
    kMemidsFieldNumber = 9,
    kTypesFieldNumber = 10,
    kInfoFieldNumber = 4,
    kIdFieldNumber = 1,
  };
  // repeated uint32 keys = 2 [packed = true];
  int keys_size() const;
  private:
  int _internal_keys_size() const;
  public:
  void clear_keys();
  private:
  uint32_t _internal_keys(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_keys() const;
  void _internal_add_keys(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_keys();
  public:
  uint32_t keys(int index) const;
  void set_keys(int index, uint32_t value);
  void add_keys(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      keys() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_keys();

  // repeated uint32 vals = 3 [packed = true];
  int vals_size() const;
  private:
  int _internal_vals_size() const;
  public:
  void clear_vals();
  private:
  uint32_t _internal_vals(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_vals() const;
  void _internal_add_vals(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_vals();
  public:
  uint32_t vals(int index) const;
  void set_vals(int index, uint32_t value);
  void add_vals(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      vals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_vals();

  // repeated int32 roles_sid = 8 [packed = true];
  int roles_sid_size() const;
  private:
  int _internal_roles_sid_size() const;
  public:
  void clear_roles_sid();
  private:
  int32_t _internal_roles_sid(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_roles_sid() const;
  void _internal_add_roles_sid(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_roles_sid();
  public:
  int32_t roles_sid(int index) const;
  void set_roles_sid(int index, int32_t value);
  void add_roles_sid(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      roles_sid() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_roles_sid();

  // repeated sint64 memids = 9 [packed = true];
  int memids_size() const;
  private:
  int _internal_memids_size() const;
  public:
  void clear_memids();
  private:
  int64_t _internal_memids(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_memids() const;
  void _internal_add_memids(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_memids();
  public:
  int64_t memids(int index) const;
  void set_memids(int index, int64_t value);
  void add_memids(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      memids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_memids();

  // repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];
  int types_size() const;
  private:
  int _internal_types_size() const;
  public:
  void clear_types();
  private:
  ::OSMPBF::Relation_MemberType _internal_types(int index) const;
  void _internal_add_types(::OSMPBF::Relation_MemberType value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_types();
  public:
  ::OSMPBF::Relation_MemberType types(int index) const;
  void set_types(int index, ::OSMPBF::Relation_MemberType value);
  void add_types(::OSMPBF::Relation_MemberType value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& types() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_types();

  // optional .OSMPBF.Info info = 4;
  bool has_info() const;
  private:
  bool _internal_has_info() const;
  public:
  void clear_info();
  const ::OSMPBF::Info& info() const;
  PROTOBUF_NODISCARD ::OSMPBF::Info* release_info();
  ::OSMPBF::Info* mutable_info();
  void set_allocated_info(::OSMPBF::Info* info);
  private:
  const ::OSMPBF::Info& _internal_info() const;
  ::OSMPBF::Info* _internal_mutable_info();
  public:
  void unsafe_arena_set_allocated_info(
      ::OSMPBF::Info* info);
  ::OSMPBF::Info* unsafe_arena_release_info();

  // required int64 id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  int64_t id() const;
  void set_id(int64_t value);
  private:
  int64_t _internal_id() const;
  void _internal_set_id(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:OSMPBF.Relation)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > keys_;
    mutable std::atomic<int> _keys_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > vals_;
    mutable std::atomic<int> _vals_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > roles_sid_;
    mutable std::atomic<int> _roles_sid_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > memids_;
    mutable std::atomic<int> _memids_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> types_;
    mutable std::atomic<int> _types_cached_byte_size_;
    ::OSMPBF::Info* info_;
    int64_t id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_osmformat_2eproto;
};
// ===================================================================


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

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

// optional .OSMPBF.HeaderBBox bbox = 1;
inline bool HeaderBlock::_internal_has_bbox() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.bbox_ != nullptr);
  return value;
}
inline bool HeaderBlock::has_bbox() const {
  return _internal_has_bbox();
}
inline void HeaderBlock::clear_bbox() {
  if (_impl_.bbox_ != nullptr) _impl_.bbox_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::OSMPBF::HeaderBBox& HeaderBlock::_internal_bbox() const {
  const ::OSMPBF::HeaderBBox* p = _impl_.bbox_;
  return p != nullptr ? *p : reinterpret_cast<const ::OSMPBF::HeaderBBox&>(
      ::OSMPBF::_HeaderBBox_default_instance_);
}
inline const ::OSMPBF::HeaderBBox& HeaderBlock::bbox() const {
  // @@protoc_insertion_point(field_get:OSMPBF.HeaderBlock.bbox)
  return _internal_bbox();
}
inline void HeaderBlock::unsafe_arena_set_allocated_bbox(
    ::OSMPBF::HeaderBBox* bbox) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.bbox_);
  }
  _impl_.bbox_ = bbox;
  if (bbox) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:OSMPBF.HeaderBlock.bbox)
}
inline ::OSMPBF::HeaderBBox* HeaderBlock::release_bbox() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::OSMPBF::HeaderBBox* temp = _impl_.bbox_;
  _impl_.bbox_ = 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 ::OSMPBF::HeaderBBox* HeaderBlock::unsafe_arena_release_bbox() {
  // @@protoc_insertion_point(field_release:OSMPBF.HeaderBlock.bbox)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::OSMPBF::HeaderBBox* temp = _impl_.bbox_;
  _impl_.bbox_ = nullptr;
  return temp;
}
inline ::OSMPBF::HeaderBBox* HeaderBlock::_internal_mutable_bbox() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.bbox_ == nullptr) {
    auto* p = CreateMaybeMessage<::OSMPBF::HeaderBBox>(GetArenaForAllocation());
    _impl_.bbox_ = p;
  }
  return _impl_.bbox_;
}
inline ::OSMPBF::HeaderBBox* HeaderBlock::mutable_bbox() {
  ::OSMPBF::HeaderBBox* _msg = _internal_mutable_bbox();
  // @@protoc_insertion_point(field_mutable:OSMPBF.HeaderBlock.bbox)
  return _msg;
}
inline void HeaderBlock::set_allocated_bbox(::OSMPBF::HeaderBBox* bbox) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.bbox_;
  }
  if (bbox) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(bbox);
    if (message_arena != submessage_arena) {
      bbox = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bbox, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.bbox_ = bbox;
  // @@protoc_insertion_point(field_set_allocated:OSMPBF.HeaderBlock.bbox)
}

// repeated string required_features = 4;
inline int HeaderBlock::_internal_required_features_size() const {
  return _impl_.required_features_.size();
}
inline int HeaderBlock::required_features_size() const {
  return _internal_required_features_size();
}
inline void HeaderBlock::clear_required_features() {
  _impl_.required_features_.Clear();
}
inline std::string* HeaderBlock::add_required_features() {
  std::string* _s = _internal_add_required_features();
  // @@protoc_insertion_point(field_add_mutable:OSMPBF.HeaderBlock.required_features)
  return _s;
}
inline const std::string& HeaderBlock::_internal_required_features(int index) const {
  return _impl_.required_features_.Get(index);
}
inline const std::string& HeaderBlock::required_features(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.HeaderBlock.required_features)
  return _internal_required_features(index);
}
inline std::string* HeaderBlock::mutable_required_features(int index) {
  // @@protoc_insertion_point(field_mutable:OSMPBF.HeaderBlock.required_features)
  return _impl_.required_features_.Mutable(index);
}
inline void HeaderBlock::set_required_features(int index, const std::string& value) {
  _impl_.required_features_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:OSMPBF.HeaderBlock.required_features)
}
inline void HeaderBlock::set_required_features(int index, std::string&& value) {
  _impl_.required_features_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:OSMPBF.HeaderBlock.required_features)
}
inline void HeaderBlock::set_required_features(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.required_features_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:OSMPBF.HeaderBlock.required_features)
}
inline void HeaderBlock::set_required_features(int index, const char* value, size_t size) {
  _impl_.required_features_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:OSMPBF.HeaderBlock.required_features)
}
inline std::string* HeaderBlock::_internal_add_required_features() {
  return _impl_.required_features_.Add();
}
inline void HeaderBlock::add_required_features(const std::string& value) {
  _impl_.required_features_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:OSMPBF.HeaderBlock.required_features)
}
inline void HeaderBlock::add_required_features(std::string&& value) {
  _impl_.required_features_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:OSMPBF.HeaderBlock.required_features)
}
inline void HeaderBlock::add_required_features(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.required_features_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:OSMPBF.HeaderBlock.required_features)
}
inline void HeaderBlock::add_required_features(const char* value, size_t size) {
  _impl_.required_features_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:OSMPBF.HeaderBlock.required_features)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
HeaderBlock::required_features() const {
  // @@protoc_insertion_point(field_list:OSMPBF.HeaderBlock.required_features)
  return _impl_.required_features_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
HeaderBlock::mutable_required_features() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.HeaderBlock.required_features)
  return &_impl_.required_features_;
}

// repeated string optional_features = 5;
inline int HeaderBlock::_internal_optional_features_size() const {
  return _impl_.optional_features_.size();
}
inline int HeaderBlock::optional_features_size() const {
  return _internal_optional_features_size();
}
inline void HeaderBlock::clear_optional_features() {
  _impl_.optional_features_.Clear();
}
inline std::string* HeaderBlock::add_optional_features() {
  std::string* _s = _internal_add_optional_features();
  // @@protoc_insertion_point(field_add_mutable:OSMPBF.HeaderBlock.optional_features)
  return _s;
}
inline const std::string& HeaderBlock::_internal_optional_features(int index) const {
  return _impl_.optional_features_.Get(index);
}
inline const std::string& HeaderBlock::optional_features(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.HeaderBlock.optional_features)
  return _internal_optional_features(index);
}
inline std::string* HeaderBlock::mutable_optional_features(int index) {
  // @@protoc_insertion_point(field_mutable:OSMPBF.HeaderBlock.optional_features)
  return _impl_.optional_features_.Mutable(index);
}
inline void HeaderBlock::set_optional_features(int index, const std::string& value) {
  _impl_.optional_features_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:OSMPBF.HeaderBlock.optional_features)
}
inline void HeaderBlock::set_optional_features(int index, std::string&& value) {
  _impl_.optional_features_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:OSMPBF.HeaderBlock.optional_features)
}
inline void HeaderBlock::set_optional_features(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.optional_features_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:OSMPBF.HeaderBlock.optional_features)
}
inline void HeaderBlock::set_optional_features(int index, const char* value, size_t size) {
  _impl_.optional_features_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:OSMPBF.HeaderBlock.optional_features)
}
inline std::string* HeaderBlock::_internal_add_optional_features() {
  return _impl_.optional_features_.Add();
}
inline void HeaderBlock::add_optional_features(const std::string& value) {
  _impl_.optional_features_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:OSMPBF.HeaderBlock.optional_features)
}
inline void HeaderBlock::add_optional_features(std::string&& value) {
  _impl_.optional_features_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:OSMPBF.HeaderBlock.optional_features)
}
inline void HeaderBlock::add_optional_features(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.optional_features_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:OSMPBF.HeaderBlock.optional_features)
}
inline void HeaderBlock::add_optional_features(const char* value, size_t size) {
  _impl_.optional_features_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:OSMPBF.HeaderBlock.optional_features)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
HeaderBlock::optional_features() const {
  // @@protoc_insertion_point(field_list:OSMPBF.HeaderBlock.optional_features)
  return _impl_.optional_features_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
HeaderBlock::mutable_optional_features() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.HeaderBlock.optional_features)
  return &_impl_.optional_features_;
}

// optional string writingprogram = 16;
inline bool HeaderBlock::_internal_has_writingprogram() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HeaderBlock::has_writingprogram() const {
  return _internal_has_writingprogram();
}
inline void HeaderBlock::clear_writingprogram() {
  _impl_.writingprogram_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& HeaderBlock::writingprogram() const {
  // @@protoc_insertion_point(field_get:OSMPBF.HeaderBlock.writingprogram)
  return _internal_writingprogram();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HeaderBlock::set_writingprogram(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.writingprogram_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:OSMPBF.HeaderBlock.writingprogram)
}
inline std::string* HeaderBlock::mutable_writingprogram() {
  std::string* _s = _internal_mutable_writingprogram();
  // @@protoc_insertion_point(field_mutable:OSMPBF.HeaderBlock.writingprogram)
  return _s;
}
inline const std::string& HeaderBlock::_internal_writingprogram() const {
  return _impl_.writingprogram_.Get();
}
inline void HeaderBlock::_internal_set_writingprogram(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.writingprogram_.Set(value, GetArenaForAllocation());
}
inline std::string* HeaderBlock::_internal_mutable_writingprogram() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.writingprogram_.Mutable(GetArenaForAllocation());
}
inline std::string* HeaderBlock::release_writingprogram() {
  // @@protoc_insertion_point(field_release:OSMPBF.HeaderBlock.writingprogram)
  if (!_internal_has_writingprogram()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.writingprogram_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.writingprogram_.IsDefault()) {
    _impl_.writingprogram_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HeaderBlock::set_allocated_writingprogram(std::string* writingprogram) {
  if (writingprogram != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.writingprogram_.SetAllocated(writingprogram, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.writingprogram_.IsDefault()) {
    _impl_.writingprogram_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:OSMPBF.HeaderBlock.writingprogram)
}

// optional string source = 17;
inline bool HeaderBlock::_internal_has_source() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool HeaderBlock::has_source() const {
  return _internal_has_source();
}
inline void HeaderBlock::clear_source() {
  _impl_.source_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& HeaderBlock::source() const {
  // @@protoc_insertion_point(field_get:OSMPBF.HeaderBlock.source)
  return _internal_source();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HeaderBlock::set_source(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.source_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:OSMPBF.HeaderBlock.source)
}
inline std::string* HeaderBlock::mutable_source() {
  std::string* _s = _internal_mutable_source();
  // @@protoc_insertion_point(field_mutable:OSMPBF.HeaderBlock.source)
  return _s;
}
inline const std::string& HeaderBlock::_internal_source() const {
  return _impl_.source_.Get();
}
inline void HeaderBlock::_internal_set_source(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.source_.Set(value, GetArenaForAllocation());
}
inline std::string* HeaderBlock::_internal_mutable_source() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.source_.Mutable(GetArenaForAllocation());
}
inline std::string* HeaderBlock::release_source() {
  // @@protoc_insertion_point(field_release:OSMPBF.HeaderBlock.source)
  if (!_internal_has_source()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.source_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HeaderBlock::set_allocated_source(std::string* source) {
  if (source != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.source_.SetAllocated(source, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.source_.IsDefault()) {
    _impl_.source_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:OSMPBF.HeaderBlock.source)
}

// optional int64 osmosis_replication_timestamp = 32;
inline bool HeaderBlock::_internal_has_osmosis_replication_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool HeaderBlock::has_osmosis_replication_timestamp() const {
  return _internal_has_osmosis_replication_timestamp();
}
inline void HeaderBlock::clear_osmosis_replication_timestamp() {
  _impl_.osmosis_replication_timestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int64_t HeaderBlock::_internal_osmosis_replication_timestamp() const {
  return _impl_.osmosis_replication_timestamp_;
}
inline int64_t HeaderBlock::osmosis_replication_timestamp() const {
  // @@protoc_insertion_point(field_get:OSMPBF.HeaderBlock.osmosis_replication_timestamp)
  return _internal_osmosis_replication_timestamp();
}
inline void HeaderBlock::_internal_set_osmosis_replication_timestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.osmosis_replication_timestamp_ = value;
}
inline void HeaderBlock::set_osmosis_replication_timestamp(int64_t value) {
  _internal_set_osmosis_replication_timestamp(value);
  // @@protoc_insertion_point(field_set:OSMPBF.HeaderBlock.osmosis_replication_timestamp)
}

// optional int64 osmosis_replication_sequence_number = 33;
inline bool HeaderBlock::_internal_has_osmosis_replication_sequence_number() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool HeaderBlock::has_osmosis_replication_sequence_number() const {
  return _internal_has_osmosis_replication_sequence_number();
}
inline void HeaderBlock::clear_osmosis_replication_sequence_number() {
  _impl_.osmosis_replication_sequence_number_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int64_t HeaderBlock::_internal_osmosis_replication_sequence_number() const {
  return _impl_.osmosis_replication_sequence_number_;
}
inline int64_t HeaderBlock::osmosis_replication_sequence_number() const {
  // @@protoc_insertion_point(field_get:OSMPBF.HeaderBlock.osmosis_replication_sequence_number)
  return _internal_osmosis_replication_sequence_number();
}
inline void HeaderBlock::_internal_set_osmosis_replication_sequence_number(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.osmosis_replication_sequence_number_ = value;
}
inline void HeaderBlock::set_osmosis_replication_sequence_number(int64_t value) {
  _internal_set_osmosis_replication_sequence_number(value);
  // @@protoc_insertion_point(field_set:OSMPBF.HeaderBlock.osmosis_replication_sequence_number)
}

// optional string osmosis_replication_base_url = 34;
inline bool HeaderBlock::_internal_has_osmosis_replication_base_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool HeaderBlock::has_osmosis_replication_base_url() const {
  return _internal_has_osmosis_replication_base_url();
}
inline void HeaderBlock::clear_osmosis_replication_base_url() {
  _impl_.osmosis_replication_base_url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& HeaderBlock::osmosis_replication_base_url() const {
  // @@protoc_insertion_point(field_get:OSMPBF.HeaderBlock.osmosis_replication_base_url)
  return _internal_osmosis_replication_base_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HeaderBlock::set_osmosis_replication_base_url(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.osmosis_replication_base_url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:OSMPBF.HeaderBlock.osmosis_replication_base_url)
}
inline std::string* HeaderBlock::mutable_osmosis_replication_base_url() {
  std::string* _s = _internal_mutable_osmosis_replication_base_url();
  // @@protoc_insertion_point(field_mutable:OSMPBF.HeaderBlock.osmosis_replication_base_url)
  return _s;
}
inline const std::string& HeaderBlock::_internal_osmosis_replication_base_url() const {
  return _impl_.osmosis_replication_base_url_.Get();
}
inline void HeaderBlock::_internal_set_osmosis_replication_base_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.osmosis_replication_base_url_.Set(value, GetArenaForAllocation());
}
inline std::string* HeaderBlock::_internal_mutable_osmosis_replication_base_url() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.osmosis_replication_base_url_.Mutable(GetArenaForAllocation());
}
inline std::string* HeaderBlock::release_osmosis_replication_base_url() {
  // @@protoc_insertion_point(field_release:OSMPBF.HeaderBlock.osmosis_replication_base_url)
  if (!_internal_has_osmosis_replication_base_url()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.osmosis_replication_base_url_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.osmosis_replication_base_url_.IsDefault()) {
    _impl_.osmosis_replication_base_url_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HeaderBlock::set_allocated_osmosis_replication_base_url(std::string* osmosis_replication_base_url) {
  if (osmosis_replication_base_url != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.osmosis_replication_base_url_.SetAllocated(osmosis_replication_base_url, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.osmosis_replication_base_url_.IsDefault()) {
    _impl_.osmosis_replication_base_url_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:OSMPBF.HeaderBlock.osmosis_replication_base_url)
}

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

// HeaderBBox

// required sint64 left = 1;
inline bool HeaderBBox::_internal_has_left() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HeaderBBox::has_left() const {
  return _internal_has_left();
}
inline void HeaderBBox::clear_left() {
  _impl_.left_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int64_t HeaderBBox::_internal_left() const {
  return _impl_.left_;
}
inline int64_t HeaderBBox::left() const {
  // @@protoc_insertion_point(field_get:OSMPBF.HeaderBBox.left)
  return _internal_left();
}
inline void HeaderBBox::_internal_set_left(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.left_ = value;
}
inline void HeaderBBox::set_left(int64_t value) {
  _internal_set_left(value);
  // @@protoc_insertion_point(field_set:OSMPBF.HeaderBBox.left)
}

// required sint64 right = 2;
inline bool HeaderBBox::_internal_has_right() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool HeaderBBox::has_right() const {
  return _internal_has_right();
}
inline void HeaderBBox::clear_right() {
  _impl_.right_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t HeaderBBox::_internal_right() const {
  return _impl_.right_;
}
inline int64_t HeaderBBox::right() const {
  // @@protoc_insertion_point(field_get:OSMPBF.HeaderBBox.right)
  return _internal_right();
}
inline void HeaderBBox::_internal_set_right(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.right_ = value;
}
inline void HeaderBBox::set_right(int64_t value) {
  _internal_set_right(value);
  // @@protoc_insertion_point(field_set:OSMPBF.HeaderBBox.right)
}

// required sint64 top = 3;
inline bool HeaderBBox::_internal_has_top() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool HeaderBBox::has_top() const {
  return _internal_has_top();
}
inline void HeaderBBox::clear_top() {
  _impl_.top_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int64_t HeaderBBox::_internal_top() const {
  return _impl_.top_;
}
inline int64_t HeaderBBox::top() const {
  // @@protoc_insertion_point(field_get:OSMPBF.HeaderBBox.top)
  return _internal_top();
}
inline void HeaderBBox::_internal_set_top(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.top_ = value;
}
inline void HeaderBBox::set_top(int64_t value) {
  _internal_set_top(value);
  // @@protoc_insertion_point(field_set:OSMPBF.HeaderBBox.top)
}

// required sint64 bottom = 4;
inline bool HeaderBBox::_internal_has_bottom() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool HeaderBBox::has_bottom() const {
  return _internal_has_bottom();
}
inline void HeaderBBox::clear_bottom() {
  _impl_.bottom_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int64_t HeaderBBox::_internal_bottom() const {
  return _impl_.bottom_;
}
inline int64_t HeaderBBox::bottom() const {
  // @@protoc_insertion_point(field_get:OSMPBF.HeaderBBox.bottom)
  return _internal_bottom();
}
inline void HeaderBBox::_internal_set_bottom(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.bottom_ = value;
}
inline void HeaderBBox::set_bottom(int64_t value) {
  _internal_set_bottom(value);
  // @@protoc_insertion_point(field_set:OSMPBF.HeaderBBox.bottom)
}

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

// PrimitiveBlock

// required .OSMPBF.StringTable stringtable = 1;
inline bool PrimitiveBlock::_internal_has_stringtable() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.stringtable_ != nullptr);
  return value;
}
inline bool PrimitiveBlock::has_stringtable() const {
  return _internal_has_stringtable();
}
inline void PrimitiveBlock::clear_stringtable() {
  if (_impl_.stringtable_ != nullptr) _impl_.stringtable_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::OSMPBF::StringTable& PrimitiveBlock::_internal_stringtable() const {
  const ::OSMPBF::StringTable* p = _impl_.stringtable_;
  return p != nullptr ? *p : reinterpret_cast<const ::OSMPBF::StringTable&>(
      ::OSMPBF::_StringTable_default_instance_);
}
inline const ::OSMPBF::StringTable& PrimitiveBlock::stringtable() const {
  // @@protoc_insertion_point(field_get:OSMPBF.PrimitiveBlock.stringtable)
  return _internal_stringtable();
}
inline void PrimitiveBlock::unsafe_arena_set_allocated_stringtable(
    ::OSMPBF::StringTable* stringtable) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stringtable_);
  }
  _impl_.stringtable_ = stringtable;
  if (stringtable) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:OSMPBF.PrimitiveBlock.stringtable)
}
inline ::OSMPBF::StringTable* PrimitiveBlock::release_stringtable() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::OSMPBF::StringTable* temp = _impl_.stringtable_;
  _impl_.stringtable_ = 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 ::OSMPBF::StringTable* PrimitiveBlock::unsafe_arena_release_stringtable() {
  // @@protoc_insertion_point(field_release:OSMPBF.PrimitiveBlock.stringtable)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::OSMPBF::StringTable* temp = _impl_.stringtable_;
  _impl_.stringtable_ = nullptr;
  return temp;
}
inline ::OSMPBF::StringTable* PrimitiveBlock::_internal_mutable_stringtable() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.stringtable_ == nullptr) {
    auto* p = CreateMaybeMessage<::OSMPBF::StringTable>(GetArenaForAllocation());
    _impl_.stringtable_ = p;
  }
  return _impl_.stringtable_;
}
inline ::OSMPBF::StringTable* PrimitiveBlock::mutable_stringtable() {
  ::OSMPBF::StringTable* _msg = _internal_mutable_stringtable();
  // @@protoc_insertion_point(field_mutable:OSMPBF.PrimitiveBlock.stringtable)
  return _msg;
}
inline void PrimitiveBlock::set_allocated_stringtable(::OSMPBF::StringTable* stringtable) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.stringtable_;
  }
  if (stringtable) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stringtable);
    if (message_arena != submessage_arena) {
      stringtable = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, stringtable, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.stringtable_ = stringtable;
  // @@protoc_insertion_point(field_set_allocated:OSMPBF.PrimitiveBlock.stringtable)
}

// repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;
inline int PrimitiveBlock::_internal_primitivegroup_size() const {
  return _impl_.primitivegroup_.size();
}
inline int PrimitiveBlock::primitivegroup_size() const {
  return _internal_primitivegroup_size();
}
inline void PrimitiveBlock::clear_primitivegroup() {
  _impl_.primitivegroup_.Clear();
}
inline ::OSMPBF::PrimitiveGroup* PrimitiveBlock::mutable_primitivegroup(int index) {
  // @@protoc_insertion_point(field_mutable:OSMPBF.PrimitiveBlock.primitivegroup)
  return _impl_.primitivegroup_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::PrimitiveGroup >*
PrimitiveBlock::mutable_primitivegroup() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.PrimitiveBlock.primitivegroup)
  return &_impl_.primitivegroup_;
}
inline const ::OSMPBF::PrimitiveGroup& PrimitiveBlock::_internal_primitivegroup(int index) const {
  return _impl_.primitivegroup_.Get(index);
}
inline const ::OSMPBF::PrimitiveGroup& PrimitiveBlock::primitivegroup(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.PrimitiveBlock.primitivegroup)
  return _internal_primitivegroup(index);
}
inline ::OSMPBF::PrimitiveGroup* PrimitiveBlock::_internal_add_primitivegroup() {
  return _impl_.primitivegroup_.Add();
}
inline ::OSMPBF::PrimitiveGroup* PrimitiveBlock::add_primitivegroup() {
  ::OSMPBF::PrimitiveGroup* _add = _internal_add_primitivegroup();
  // @@protoc_insertion_point(field_add:OSMPBF.PrimitiveBlock.primitivegroup)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::PrimitiveGroup >&
PrimitiveBlock::primitivegroup() const {
  // @@protoc_insertion_point(field_list:OSMPBF.PrimitiveBlock.primitivegroup)
  return _impl_.primitivegroup_;
}

// optional int32 granularity = 17 [default = 100];
inline bool PrimitiveBlock::_internal_has_granularity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool PrimitiveBlock::has_granularity() const {
  return _internal_has_granularity();
}
inline void PrimitiveBlock::clear_granularity() {
  _impl_.granularity_ = 100;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t PrimitiveBlock::_internal_granularity() const {
  return _impl_.granularity_;
}
inline int32_t PrimitiveBlock::granularity() const {
  // @@protoc_insertion_point(field_get:OSMPBF.PrimitiveBlock.granularity)
  return _internal_granularity();
}
inline void PrimitiveBlock::_internal_set_granularity(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.granularity_ = value;
}
inline void PrimitiveBlock::set_granularity(int32_t value) {
  _internal_set_granularity(value);
  // @@protoc_insertion_point(field_set:OSMPBF.PrimitiveBlock.granularity)
}

// optional int64 lat_offset = 19 [default = 0];
inline bool PrimitiveBlock::_internal_has_lat_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PrimitiveBlock::has_lat_offset() const {
  return _internal_has_lat_offset();
}
inline void PrimitiveBlock::clear_lat_offset() {
  _impl_.lat_offset_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t PrimitiveBlock::_internal_lat_offset() const {
  return _impl_.lat_offset_;
}
inline int64_t PrimitiveBlock::lat_offset() const {
  // @@protoc_insertion_point(field_get:OSMPBF.PrimitiveBlock.lat_offset)
  return _internal_lat_offset();
}
inline void PrimitiveBlock::_internal_set_lat_offset(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.lat_offset_ = value;
}
inline void PrimitiveBlock::set_lat_offset(int64_t value) {
  _internal_set_lat_offset(value);
  // @@protoc_insertion_point(field_set:OSMPBF.PrimitiveBlock.lat_offset)
}

// optional int64 lon_offset = 20 [default = 0];
inline bool PrimitiveBlock::_internal_has_lon_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool PrimitiveBlock::has_lon_offset() const {
  return _internal_has_lon_offset();
}
inline void PrimitiveBlock::clear_lon_offset() {
  _impl_.lon_offset_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int64_t PrimitiveBlock::_internal_lon_offset() const {
  return _impl_.lon_offset_;
}
inline int64_t PrimitiveBlock::lon_offset() const {
  // @@protoc_insertion_point(field_get:OSMPBF.PrimitiveBlock.lon_offset)
  return _internal_lon_offset();
}
inline void PrimitiveBlock::_internal_set_lon_offset(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.lon_offset_ = value;
}
inline void PrimitiveBlock::set_lon_offset(int64_t value) {
  _internal_set_lon_offset(value);
  // @@protoc_insertion_point(field_set:OSMPBF.PrimitiveBlock.lon_offset)
}

// optional int32 date_granularity = 18 [default = 1000];
inline bool PrimitiveBlock::_internal_has_date_granularity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool PrimitiveBlock::has_date_granularity() const {
  return _internal_has_date_granularity();
}
inline void PrimitiveBlock::clear_date_granularity() {
  _impl_.date_granularity_ = 1000;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int32_t PrimitiveBlock::_internal_date_granularity() const {
  return _impl_.date_granularity_;
}
inline int32_t PrimitiveBlock::date_granularity() const {
  // @@protoc_insertion_point(field_get:OSMPBF.PrimitiveBlock.date_granularity)
  return _internal_date_granularity();
}
inline void PrimitiveBlock::_internal_set_date_granularity(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.date_granularity_ = value;
}
inline void PrimitiveBlock::set_date_granularity(int32_t value) {
  _internal_set_date_granularity(value);
  // @@protoc_insertion_point(field_set:OSMPBF.PrimitiveBlock.date_granularity)
}

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

// PrimitiveGroup

// repeated .OSMPBF.Node nodes = 1;
inline int PrimitiveGroup::_internal_nodes_size() const {
  return _impl_.nodes_.size();
}
inline int PrimitiveGroup::nodes_size() const {
  return _internal_nodes_size();
}
inline void PrimitiveGroup::clear_nodes() {
  _impl_.nodes_.Clear();
}
inline ::OSMPBF::Node* PrimitiveGroup::mutable_nodes(int index) {
  // @@protoc_insertion_point(field_mutable:OSMPBF.PrimitiveGroup.nodes)
  return _impl_.nodes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::Node >*
PrimitiveGroup::mutable_nodes() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.PrimitiveGroup.nodes)
  return &_impl_.nodes_;
}
inline const ::OSMPBF::Node& PrimitiveGroup::_internal_nodes(int index) const {
  return _impl_.nodes_.Get(index);
}
inline const ::OSMPBF::Node& PrimitiveGroup::nodes(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.PrimitiveGroup.nodes)
  return _internal_nodes(index);
}
inline ::OSMPBF::Node* PrimitiveGroup::_internal_add_nodes() {
  return _impl_.nodes_.Add();
}
inline ::OSMPBF::Node* PrimitiveGroup::add_nodes() {
  ::OSMPBF::Node* _add = _internal_add_nodes();
  // @@protoc_insertion_point(field_add:OSMPBF.PrimitiveGroup.nodes)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::Node >&
PrimitiveGroup::nodes() const {
  // @@protoc_insertion_point(field_list:OSMPBF.PrimitiveGroup.nodes)
  return _impl_.nodes_;
}

// optional .OSMPBF.DenseNodes dense = 2;
inline bool PrimitiveGroup::_internal_has_dense() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.dense_ != nullptr);
  return value;
}
inline bool PrimitiveGroup::has_dense() const {
  return _internal_has_dense();
}
inline void PrimitiveGroup::clear_dense() {
  if (_impl_.dense_ != nullptr) _impl_.dense_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::OSMPBF::DenseNodes& PrimitiveGroup::_internal_dense() const {
  const ::OSMPBF::DenseNodes* p = _impl_.dense_;
  return p != nullptr ? *p : reinterpret_cast<const ::OSMPBF::DenseNodes&>(
      ::OSMPBF::_DenseNodes_default_instance_);
}
inline const ::OSMPBF::DenseNodes& PrimitiveGroup::dense() const {
  // @@protoc_insertion_point(field_get:OSMPBF.PrimitiveGroup.dense)
  return _internal_dense();
}
inline void PrimitiveGroup::unsafe_arena_set_allocated_dense(
    ::OSMPBF::DenseNodes* dense) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dense_);
  }
  _impl_.dense_ = dense;
  if (dense) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:OSMPBF.PrimitiveGroup.dense)
}
inline ::OSMPBF::DenseNodes* PrimitiveGroup::release_dense() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::OSMPBF::DenseNodes* temp = _impl_.dense_;
  _impl_.dense_ = 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 ::OSMPBF::DenseNodes* PrimitiveGroup::unsafe_arena_release_dense() {
  // @@protoc_insertion_point(field_release:OSMPBF.PrimitiveGroup.dense)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::OSMPBF::DenseNodes* temp = _impl_.dense_;
  _impl_.dense_ = nullptr;
  return temp;
}
inline ::OSMPBF::DenseNodes* PrimitiveGroup::_internal_mutable_dense() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.dense_ == nullptr) {
    auto* p = CreateMaybeMessage<::OSMPBF::DenseNodes>(GetArenaForAllocation());
    _impl_.dense_ = p;
  }
  return _impl_.dense_;
}
inline ::OSMPBF::DenseNodes* PrimitiveGroup::mutable_dense() {
  ::OSMPBF::DenseNodes* _msg = _internal_mutable_dense();
  // @@protoc_insertion_point(field_mutable:OSMPBF.PrimitiveGroup.dense)
  return _msg;
}
inline void PrimitiveGroup::set_allocated_dense(::OSMPBF::DenseNodes* dense) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.dense_;
  }
  if (dense) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(dense);
    if (message_arena != submessage_arena) {
      dense = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dense, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.dense_ = dense;
  // @@protoc_insertion_point(field_set_allocated:OSMPBF.PrimitiveGroup.dense)
}

// repeated .OSMPBF.Way ways = 3;
inline int PrimitiveGroup::_internal_ways_size() const {
  return _impl_.ways_.size();
}
inline int PrimitiveGroup::ways_size() const {
  return _internal_ways_size();
}
inline void PrimitiveGroup::clear_ways() {
  _impl_.ways_.Clear();
}
inline ::OSMPBF::Way* PrimitiveGroup::mutable_ways(int index) {
  // @@protoc_insertion_point(field_mutable:OSMPBF.PrimitiveGroup.ways)
  return _impl_.ways_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::Way >*
PrimitiveGroup::mutable_ways() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.PrimitiveGroup.ways)
  return &_impl_.ways_;
}
inline const ::OSMPBF::Way& PrimitiveGroup::_internal_ways(int index) const {
  return _impl_.ways_.Get(index);
}
inline const ::OSMPBF::Way& PrimitiveGroup::ways(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.PrimitiveGroup.ways)
  return _internal_ways(index);
}
inline ::OSMPBF::Way* PrimitiveGroup::_internal_add_ways() {
  return _impl_.ways_.Add();
}
inline ::OSMPBF::Way* PrimitiveGroup::add_ways() {
  ::OSMPBF::Way* _add = _internal_add_ways();
  // @@protoc_insertion_point(field_add:OSMPBF.PrimitiveGroup.ways)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::Way >&
PrimitiveGroup::ways() const {
  // @@protoc_insertion_point(field_list:OSMPBF.PrimitiveGroup.ways)
  return _impl_.ways_;
}

// repeated .OSMPBF.Relation relations = 4;
inline int PrimitiveGroup::_internal_relations_size() const {
  return _impl_.relations_.size();
}
inline int PrimitiveGroup::relations_size() const {
  return _internal_relations_size();
}
inline void PrimitiveGroup::clear_relations() {
  _impl_.relations_.Clear();
}
inline ::OSMPBF::Relation* PrimitiveGroup::mutable_relations(int index) {
  // @@protoc_insertion_point(field_mutable:OSMPBF.PrimitiveGroup.relations)
  return _impl_.relations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::Relation >*
PrimitiveGroup::mutable_relations() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.PrimitiveGroup.relations)
  return &_impl_.relations_;
}
inline const ::OSMPBF::Relation& PrimitiveGroup::_internal_relations(int index) const {
  return _impl_.relations_.Get(index);
}
inline const ::OSMPBF::Relation& PrimitiveGroup::relations(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.PrimitiveGroup.relations)
  return _internal_relations(index);
}
inline ::OSMPBF::Relation* PrimitiveGroup::_internal_add_relations() {
  return _impl_.relations_.Add();
}
inline ::OSMPBF::Relation* PrimitiveGroup::add_relations() {
  ::OSMPBF::Relation* _add = _internal_add_relations();
  // @@protoc_insertion_point(field_add:OSMPBF.PrimitiveGroup.relations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::Relation >&
PrimitiveGroup::relations() const {
  // @@protoc_insertion_point(field_list:OSMPBF.PrimitiveGroup.relations)
  return _impl_.relations_;
}

// repeated .OSMPBF.ChangeSet changesets = 5;
inline int PrimitiveGroup::_internal_changesets_size() const {
  return _impl_.changesets_.size();
}
inline int PrimitiveGroup::changesets_size() const {
  return _internal_changesets_size();
}
inline void PrimitiveGroup::clear_changesets() {
  _impl_.changesets_.Clear();
}
inline ::OSMPBF::ChangeSet* PrimitiveGroup::mutable_changesets(int index) {
  // @@protoc_insertion_point(field_mutable:OSMPBF.PrimitiveGroup.changesets)
  return _impl_.changesets_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::ChangeSet >*
PrimitiveGroup::mutable_changesets() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.PrimitiveGroup.changesets)
  return &_impl_.changesets_;
}
inline const ::OSMPBF::ChangeSet& PrimitiveGroup::_internal_changesets(int index) const {
  return _impl_.changesets_.Get(index);
}
inline const ::OSMPBF::ChangeSet& PrimitiveGroup::changesets(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.PrimitiveGroup.changesets)
  return _internal_changesets(index);
}
inline ::OSMPBF::ChangeSet* PrimitiveGroup::_internal_add_changesets() {
  return _impl_.changesets_.Add();
}
inline ::OSMPBF::ChangeSet* PrimitiveGroup::add_changesets() {
  ::OSMPBF::ChangeSet* _add = _internal_add_changesets();
  // @@protoc_insertion_point(field_add:OSMPBF.PrimitiveGroup.changesets)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OSMPBF::ChangeSet >&
PrimitiveGroup::changesets() const {
  // @@protoc_insertion_point(field_list:OSMPBF.PrimitiveGroup.changesets)
  return _impl_.changesets_;
}

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

// StringTable

// repeated bytes s = 1;
inline int StringTable::_internal_s_size() const {
  return _impl_.s_.size();
}
inline int StringTable::s_size() const {
  return _internal_s_size();
}
inline void StringTable::clear_s() {
  _impl_.s_.Clear();
}
inline std::string* StringTable::add_s() {
  std::string* _s = _internal_add_s();
  // @@protoc_insertion_point(field_add_mutable:OSMPBF.StringTable.s)
  return _s;
}
inline const std::string& StringTable::_internal_s(int index) const {
  return _impl_.s_.Get(index);
}
inline const std::string& StringTable::s(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.StringTable.s)
  return _internal_s(index);
}
inline std::string* StringTable::mutable_s(int index) {
  // @@protoc_insertion_point(field_mutable:OSMPBF.StringTable.s)
  return _impl_.s_.Mutable(index);
}
inline void StringTable::set_s(int index, const std::string& value) {
  _impl_.s_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:OSMPBF.StringTable.s)
}
inline void StringTable::set_s(int index, std::string&& value) {
  _impl_.s_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:OSMPBF.StringTable.s)
}
inline void StringTable::set_s(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.s_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:OSMPBF.StringTable.s)
}
inline void StringTable::set_s(int index, const void* value, size_t size) {
  _impl_.s_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:OSMPBF.StringTable.s)
}
inline std::string* StringTable::_internal_add_s() {
  return _impl_.s_.Add();
}
inline void StringTable::add_s(const std::string& value) {
  _impl_.s_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:OSMPBF.StringTable.s)
}
inline void StringTable::add_s(std::string&& value) {
  _impl_.s_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:OSMPBF.StringTable.s)
}
inline void StringTable::add_s(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.s_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:OSMPBF.StringTable.s)
}
inline void StringTable::add_s(const void* value, size_t size) {
  _impl_.s_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:OSMPBF.StringTable.s)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
StringTable::s() const {
  // @@protoc_insertion_point(field_list:OSMPBF.StringTable.s)
  return _impl_.s_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
StringTable::mutable_s() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.StringTable.s)
  return &_impl_.s_;
}

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

// Info

// optional int32 version = 1 [default = -1];
inline bool Info::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Info::has_version() const {
  return _internal_has_version();
}
inline void Info::clear_version() {
  _impl_.version_ = -1;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline int32_t Info::_internal_version() const {
  return _impl_.version_;
}
inline int32_t Info::version() const {
  // @@protoc_insertion_point(field_get:OSMPBF.Info.version)
  return _internal_version();
}
inline void Info::_internal_set_version(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.version_ = value;
}
inline void Info::set_version(int32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:OSMPBF.Info.version)
}

// optional int64 timestamp = 2;
inline bool Info::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Info::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void Info::clear_timestamp() {
  _impl_.timestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int64_t Info::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline int64_t Info::timestamp() const {
  // @@protoc_insertion_point(field_get:OSMPBF.Info.timestamp)
  return _internal_timestamp();
}
inline void Info::_internal_set_timestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.timestamp_ = value;
}
inline void Info::set_timestamp(int64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:OSMPBF.Info.timestamp)
}

// optional int64 changeset = 3;
inline bool Info::_internal_has_changeset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Info::has_changeset() const {
  return _internal_has_changeset();
}
inline void Info::clear_changeset() {
  _impl_.changeset_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t Info::_internal_changeset() const {
  return _impl_.changeset_;
}
inline int64_t Info::changeset() const {
  // @@protoc_insertion_point(field_get:OSMPBF.Info.changeset)
  return _internal_changeset();
}
inline void Info::_internal_set_changeset(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.changeset_ = value;
}
inline void Info::set_changeset(int64_t value) {
  _internal_set_changeset(value);
  // @@protoc_insertion_point(field_set:OSMPBF.Info.changeset)
}

// optional int32 uid = 4;
inline bool Info::_internal_has_uid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Info::has_uid() const {
  return _internal_has_uid();
}
inline void Info::clear_uid() {
  _impl_.uid_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t Info::_internal_uid() const {
  return _impl_.uid_;
}
inline int32_t Info::uid() const {
  // @@protoc_insertion_point(field_get:OSMPBF.Info.uid)
  return _internal_uid();
}
inline void Info::_internal_set_uid(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.uid_ = value;
}
inline void Info::set_uid(int32_t value) {
  _internal_set_uid(value);
  // @@protoc_insertion_point(field_set:OSMPBF.Info.uid)
}

// optional uint32 user_sid = 5;
inline bool Info::_internal_has_user_sid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Info::has_user_sid() const {
  return _internal_has_user_sid();
}
inline void Info::clear_user_sid() {
  _impl_.user_sid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t Info::_internal_user_sid() const {
  return _impl_.user_sid_;
}
inline uint32_t Info::user_sid() const {
  // @@protoc_insertion_point(field_get:OSMPBF.Info.user_sid)
  return _internal_user_sid();
}
inline void Info::_internal_set_user_sid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.user_sid_ = value;
}
inline void Info::set_user_sid(uint32_t value) {
  _internal_set_user_sid(value);
  // @@protoc_insertion_point(field_set:OSMPBF.Info.user_sid)
}

// optional bool visible = 6;
inline bool Info::_internal_has_visible() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Info::has_visible() const {
  return _internal_has_visible();
}
inline void Info::clear_visible() {
  _impl_.visible_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool Info::_internal_visible() const {
  return _impl_.visible_;
}
inline bool Info::visible() const {
  // @@protoc_insertion_point(field_get:OSMPBF.Info.visible)
  return _internal_visible();
}
inline void Info::_internal_set_visible(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.visible_ = value;
}
inline void Info::set_visible(bool value) {
  _internal_set_visible(value);
  // @@protoc_insertion_point(field_set:OSMPBF.Info.visible)
}

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

// DenseInfo

// repeated int32 version = 1 [packed = true];
inline int DenseInfo::_internal_version_size() const {
  return _impl_.version_.size();
}
inline int DenseInfo::version_size() const {
  return _internal_version_size();
}
inline void DenseInfo::clear_version() {
  _impl_.version_.Clear();
}
inline int32_t DenseInfo::_internal_version(int index) const {
  return _impl_.version_.Get(index);
}
inline int32_t DenseInfo::version(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.DenseInfo.version)
  return _internal_version(index);
}
inline void DenseInfo::set_version(int index, int32_t value) {
  _impl_.version_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.DenseInfo.version)
}
inline void DenseInfo::_internal_add_version(int32_t value) {
  _impl_.version_.Add(value);
}
inline void DenseInfo::add_version(int32_t value) {
  _internal_add_version(value);
  // @@protoc_insertion_point(field_add:OSMPBF.DenseInfo.version)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
DenseInfo::_internal_version() const {
  return _impl_.version_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
DenseInfo::version() const {
  // @@protoc_insertion_point(field_list:OSMPBF.DenseInfo.version)
  return _internal_version();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
DenseInfo::_internal_mutable_version() {
  return &_impl_.version_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
DenseInfo::mutable_version() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.DenseInfo.version)
  return _internal_mutable_version();
}

// repeated sint64 timestamp = 2 [packed = true];
inline int DenseInfo::_internal_timestamp_size() const {
  return _impl_.timestamp_.size();
}
inline int DenseInfo::timestamp_size() const {
  return _internal_timestamp_size();
}
inline void DenseInfo::clear_timestamp() {
  _impl_.timestamp_.Clear();
}
inline int64_t DenseInfo::_internal_timestamp(int index) const {
  return _impl_.timestamp_.Get(index);
}
inline int64_t DenseInfo::timestamp(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.DenseInfo.timestamp)
  return _internal_timestamp(index);
}
inline void DenseInfo::set_timestamp(int index, int64_t value) {
  _impl_.timestamp_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.DenseInfo.timestamp)
}
inline void DenseInfo::_internal_add_timestamp(int64_t value) {
  _impl_.timestamp_.Add(value);
}
inline void DenseInfo::add_timestamp(int64_t value) {
  _internal_add_timestamp(value);
  // @@protoc_insertion_point(field_add:OSMPBF.DenseInfo.timestamp)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
DenseInfo::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
DenseInfo::timestamp() const {
  // @@protoc_insertion_point(field_list:OSMPBF.DenseInfo.timestamp)
  return _internal_timestamp();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
DenseInfo::_internal_mutable_timestamp() {
  return &_impl_.timestamp_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
DenseInfo::mutable_timestamp() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.DenseInfo.timestamp)
  return _internal_mutable_timestamp();
}

// repeated sint64 changeset = 3 [packed = true];
inline int DenseInfo::_internal_changeset_size() const {
  return _impl_.changeset_.size();
}
inline int DenseInfo::changeset_size() const {
  return _internal_changeset_size();
}
inline void DenseInfo::clear_changeset() {
  _impl_.changeset_.Clear();
}
inline int64_t DenseInfo::_internal_changeset(int index) const {
  return _impl_.changeset_.Get(index);
}
inline int64_t DenseInfo::changeset(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.DenseInfo.changeset)
  return _internal_changeset(index);
}
inline void DenseInfo::set_changeset(int index, int64_t value) {
  _impl_.changeset_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.DenseInfo.changeset)
}
inline void DenseInfo::_internal_add_changeset(int64_t value) {
  _impl_.changeset_.Add(value);
}
inline void DenseInfo::add_changeset(int64_t value) {
  _internal_add_changeset(value);
  // @@protoc_insertion_point(field_add:OSMPBF.DenseInfo.changeset)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
DenseInfo::_internal_changeset() const {
  return _impl_.changeset_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
DenseInfo::changeset() const {
  // @@protoc_insertion_point(field_list:OSMPBF.DenseInfo.changeset)
  return _internal_changeset();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
DenseInfo::_internal_mutable_changeset() {
  return &_impl_.changeset_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
DenseInfo::mutable_changeset() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.DenseInfo.changeset)
  return _internal_mutable_changeset();
}

// repeated sint32 uid = 4 [packed = true];
inline int DenseInfo::_internal_uid_size() const {
  return _impl_.uid_.size();
}
inline int DenseInfo::uid_size() const {
  return _internal_uid_size();
}
inline void DenseInfo::clear_uid() {
  _impl_.uid_.Clear();
}
inline int32_t DenseInfo::_internal_uid(int index) const {
  return _impl_.uid_.Get(index);
}
inline int32_t DenseInfo::uid(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.DenseInfo.uid)
  return _internal_uid(index);
}
inline void DenseInfo::set_uid(int index, int32_t value) {
  _impl_.uid_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.DenseInfo.uid)
}
inline void DenseInfo::_internal_add_uid(int32_t value) {
  _impl_.uid_.Add(value);
}
inline void DenseInfo::add_uid(int32_t value) {
  _internal_add_uid(value);
  // @@protoc_insertion_point(field_add:OSMPBF.DenseInfo.uid)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
DenseInfo::_internal_uid() const {
  return _impl_.uid_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
DenseInfo::uid() const {
  // @@protoc_insertion_point(field_list:OSMPBF.DenseInfo.uid)
  return _internal_uid();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
DenseInfo::_internal_mutable_uid() {
  return &_impl_.uid_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
DenseInfo::mutable_uid() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.DenseInfo.uid)
  return _internal_mutable_uid();
}

// repeated sint32 user_sid = 5 [packed = true];
inline int DenseInfo::_internal_user_sid_size() const {
  return _impl_.user_sid_.size();
}
inline int DenseInfo::user_sid_size() const {
  return _internal_user_sid_size();
}
inline void DenseInfo::clear_user_sid() {
  _impl_.user_sid_.Clear();
}
inline int32_t DenseInfo::_internal_user_sid(int index) const {
  return _impl_.user_sid_.Get(index);
}
inline int32_t DenseInfo::user_sid(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.DenseInfo.user_sid)
  return _internal_user_sid(index);
}
inline void DenseInfo::set_user_sid(int index, int32_t value) {
  _impl_.user_sid_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.DenseInfo.user_sid)
}
inline void DenseInfo::_internal_add_user_sid(int32_t value) {
  _impl_.user_sid_.Add(value);
}
inline void DenseInfo::add_user_sid(int32_t value) {
  _internal_add_user_sid(value);
  // @@protoc_insertion_point(field_add:OSMPBF.DenseInfo.user_sid)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
DenseInfo::_internal_user_sid() const {
  return _impl_.user_sid_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
DenseInfo::user_sid() const {
  // @@protoc_insertion_point(field_list:OSMPBF.DenseInfo.user_sid)
  return _internal_user_sid();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
DenseInfo::_internal_mutable_user_sid() {
  return &_impl_.user_sid_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
DenseInfo::mutable_user_sid() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.DenseInfo.user_sid)
  return _internal_mutable_user_sid();
}

// repeated bool visible = 6 [packed = true];
inline int DenseInfo::_internal_visible_size() const {
  return _impl_.visible_.size();
}
inline int DenseInfo::visible_size() const {
  return _internal_visible_size();
}
inline void DenseInfo::clear_visible() {
  _impl_.visible_.Clear();
}
inline bool DenseInfo::_internal_visible(int index) const {
  return _impl_.visible_.Get(index);
}
inline bool DenseInfo::visible(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.DenseInfo.visible)
  return _internal_visible(index);
}
inline void DenseInfo::set_visible(int index, bool value) {
  _impl_.visible_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.DenseInfo.visible)
}
inline void DenseInfo::_internal_add_visible(bool value) {
  _impl_.visible_.Add(value);
}
inline void DenseInfo::add_visible(bool value) {
  _internal_add_visible(value);
  // @@protoc_insertion_point(field_add:OSMPBF.DenseInfo.visible)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
DenseInfo::_internal_visible() const {
  return _impl_.visible_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
DenseInfo::visible() const {
  // @@protoc_insertion_point(field_list:OSMPBF.DenseInfo.visible)
  return _internal_visible();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
DenseInfo::_internal_mutable_visible() {
  return &_impl_.visible_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
DenseInfo::mutable_visible() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.DenseInfo.visible)
  return _internal_mutable_visible();
}

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

// ChangeSet

// required int64 id = 1;
inline bool ChangeSet::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ChangeSet::has_id() const {
  return _internal_has_id();
}
inline void ChangeSet::clear_id() {
  _impl_.id_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int64_t ChangeSet::_internal_id() const {
  return _impl_.id_;
}
inline int64_t ChangeSet::id() const {
  // @@protoc_insertion_point(field_get:OSMPBF.ChangeSet.id)
  return _internal_id();
}
inline void ChangeSet::_internal_set_id(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.id_ = value;
}
inline void ChangeSet::set_id(int64_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:OSMPBF.ChangeSet.id)
}

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

// Node

// required sint64 id = 1;
inline bool Node::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Node::has_id() const {
  return _internal_has_id();
}
inline void Node::clear_id() {
  _impl_.id_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t Node::_internal_id() const {
  return _impl_.id_;
}
inline int64_t Node::id() const {
  // @@protoc_insertion_point(field_get:OSMPBF.Node.id)
  return _internal_id();
}
inline void Node::_internal_set_id(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.id_ = value;
}
inline void Node::set_id(int64_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:OSMPBF.Node.id)
}

// repeated uint32 keys = 2 [packed = true];
inline int Node::_internal_keys_size() const {
  return _impl_.keys_.size();
}
inline int Node::keys_size() const {
  return _internal_keys_size();
}
inline void Node::clear_keys() {
  _impl_.keys_.Clear();
}
inline uint32_t Node::_internal_keys(int index) const {
  return _impl_.keys_.Get(index);
}
inline uint32_t Node::keys(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.Node.keys)
  return _internal_keys(index);
}
inline void Node::set_keys(int index, uint32_t value) {
  _impl_.keys_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.Node.keys)
}
inline void Node::_internal_add_keys(uint32_t value) {
  _impl_.keys_.Add(value);
}
inline void Node::add_keys(uint32_t value) {
  _internal_add_keys(value);
  // @@protoc_insertion_point(field_add:OSMPBF.Node.keys)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Node::_internal_keys() const {
  return _impl_.keys_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Node::keys() const {
  // @@protoc_insertion_point(field_list:OSMPBF.Node.keys)
  return _internal_keys();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Node::_internal_mutable_keys() {
  return &_impl_.keys_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Node::mutable_keys() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.Node.keys)
  return _internal_mutable_keys();
}

// repeated uint32 vals = 3 [packed = true];
inline int Node::_internal_vals_size() const {
  return _impl_.vals_.size();
}
inline int Node::vals_size() const {
  return _internal_vals_size();
}
inline void Node::clear_vals() {
  _impl_.vals_.Clear();
}
inline uint32_t Node::_internal_vals(int index) const {
  return _impl_.vals_.Get(index);
}
inline uint32_t Node::vals(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.Node.vals)
  return _internal_vals(index);
}
inline void Node::set_vals(int index, uint32_t value) {
  _impl_.vals_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.Node.vals)
}
inline void Node::_internal_add_vals(uint32_t value) {
  _impl_.vals_.Add(value);
}
inline void Node::add_vals(uint32_t value) {
  _internal_add_vals(value);
  // @@protoc_insertion_point(field_add:OSMPBF.Node.vals)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Node::_internal_vals() const {
  return _impl_.vals_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Node::vals() const {
  // @@protoc_insertion_point(field_list:OSMPBF.Node.vals)
  return _internal_vals();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Node::_internal_mutable_vals() {
  return &_impl_.vals_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Node::mutable_vals() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.Node.vals)
  return _internal_mutable_vals();
}

// optional .OSMPBF.Info info = 4;
inline bool Node::_internal_has_info() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.info_ != nullptr);
  return value;
}
inline bool Node::has_info() const {
  return _internal_has_info();
}
inline void Node::clear_info() {
  if (_impl_.info_ != nullptr) _impl_.info_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::OSMPBF::Info& Node::_internal_info() const {
  const ::OSMPBF::Info* p = _impl_.info_;
  return p != nullptr ? *p : reinterpret_cast<const ::OSMPBF::Info&>(
      ::OSMPBF::_Info_default_instance_);
}
inline const ::OSMPBF::Info& Node::info() const {
  // @@protoc_insertion_point(field_get:OSMPBF.Node.info)
  return _internal_info();
}
inline void Node::unsafe_arena_set_allocated_info(
    ::OSMPBF::Info* info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.info_);
  }
  _impl_.info_ = info;
  if (info) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:OSMPBF.Node.info)
}
inline ::OSMPBF::Info* Node::release_info() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::OSMPBF::Info* temp = _impl_.info_;
  _impl_.info_ = 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 ::OSMPBF::Info* Node::unsafe_arena_release_info() {
  // @@protoc_insertion_point(field_release:OSMPBF.Node.info)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::OSMPBF::Info* temp = _impl_.info_;
  _impl_.info_ = nullptr;
  return temp;
}
inline ::OSMPBF::Info* Node::_internal_mutable_info() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.info_ == nullptr) {
    auto* p = CreateMaybeMessage<::OSMPBF::Info>(GetArenaForAllocation());
    _impl_.info_ = p;
  }
  return _impl_.info_;
}
inline ::OSMPBF::Info* Node::mutable_info() {
  ::OSMPBF::Info* _msg = _internal_mutable_info();
  // @@protoc_insertion_point(field_mutable:OSMPBF.Node.info)
  return _msg;
}
inline void Node::set_allocated_info(::OSMPBF::Info* info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.info_;
  }
  if (info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(info);
    if (message_arena != submessage_arena) {
      info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, info, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.info_ = info;
  // @@protoc_insertion_point(field_set_allocated:OSMPBF.Node.info)
}

// required sint64 lat = 8;
inline bool Node::_internal_has_lat() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Node::has_lat() const {
  return _internal_has_lat();
}
inline void Node::clear_lat() {
  _impl_.lat_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int64_t Node::_internal_lat() const {
  return _impl_.lat_;
}
inline int64_t Node::lat() const {
  // @@protoc_insertion_point(field_get:OSMPBF.Node.lat)
  return _internal_lat();
}
inline void Node::_internal_set_lat(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.lat_ = value;
}
inline void Node::set_lat(int64_t value) {
  _internal_set_lat(value);
  // @@protoc_insertion_point(field_set:OSMPBF.Node.lat)
}

// required sint64 lon = 9;
inline bool Node::_internal_has_lon() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Node::has_lon() const {
  return _internal_has_lon();
}
inline void Node::clear_lon() {
  _impl_.lon_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int64_t Node::_internal_lon() const {
  return _impl_.lon_;
}
inline int64_t Node::lon() const {
  // @@protoc_insertion_point(field_get:OSMPBF.Node.lon)
  return _internal_lon();
}
inline void Node::_internal_set_lon(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.lon_ = value;
}
inline void Node::set_lon(int64_t value) {
  _internal_set_lon(value);
  // @@protoc_insertion_point(field_set:OSMPBF.Node.lon)
}

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

// DenseNodes

// repeated sint64 id = 1 [packed = true];
inline int DenseNodes::_internal_id_size() const {
  return _impl_.id_.size();
}
inline int DenseNodes::id_size() const {
  return _internal_id_size();
}
inline void DenseNodes::clear_id() {
  _impl_.id_.Clear();
}
inline int64_t DenseNodes::_internal_id(int index) const {
  return _impl_.id_.Get(index);
}
inline int64_t DenseNodes::id(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.DenseNodes.id)
  return _internal_id(index);
}
inline void DenseNodes::set_id(int index, int64_t value) {
  _impl_.id_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.DenseNodes.id)
}
inline void DenseNodes::_internal_add_id(int64_t value) {
  _impl_.id_.Add(value);
}
inline void DenseNodes::add_id(int64_t value) {
  _internal_add_id(value);
  // @@protoc_insertion_point(field_add:OSMPBF.DenseNodes.id)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
DenseNodes::_internal_id() const {
  return _impl_.id_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
DenseNodes::id() const {
  // @@protoc_insertion_point(field_list:OSMPBF.DenseNodes.id)
  return _internal_id();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
DenseNodes::_internal_mutable_id() {
  return &_impl_.id_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
DenseNodes::mutable_id() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.DenseNodes.id)
  return _internal_mutable_id();
}

// optional .OSMPBF.DenseInfo denseinfo = 5;
inline bool DenseNodes::_internal_has_denseinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.denseinfo_ != nullptr);
  return value;
}
inline bool DenseNodes::has_denseinfo() const {
  return _internal_has_denseinfo();
}
inline void DenseNodes::clear_denseinfo() {
  if (_impl_.denseinfo_ != nullptr) _impl_.denseinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::OSMPBF::DenseInfo& DenseNodes::_internal_denseinfo() const {
  const ::OSMPBF::DenseInfo* p = _impl_.denseinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::OSMPBF::DenseInfo&>(
      ::OSMPBF::_DenseInfo_default_instance_);
}
inline const ::OSMPBF::DenseInfo& DenseNodes::denseinfo() const {
  // @@protoc_insertion_point(field_get:OSMPBF.DenseNodes.denseinfo)
  return _internal_denseinfo();
}
inline void DenseNodes::unsafe_arena_set_allocated_denseinfo(
    ::OSMPBF::DenseInfo* denseinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.denseinfo_);
  }
  _impl_.denseinfo_ = denseinfo;
  if (denseinfo) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:OSMPBF.DenseNodes.denseinfo)
}
inline ::OSMPBF::DenseInfo* DenseNodes::release_denseinfo() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::OSMPBF::DenseInfo* temp = _impl_.denseinfo_;
  _impl_.denseinfo_ = 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 ::OSMPBF::DenseInfo* DenseNodes::unsafe_arena_release_denseinfo() {
  // @@protoc_insertion_point(field_release:OSMPBF.DenseNodes.denseinfo)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::OSMPBF::DenseInfo* temp = _impl_.denseinfo_;
  _impl_.denseinfo_ = nullptr;
  return temp;
}
inline ::OSMPBF::DenseInfo* DenseNodes::_internal_mutable_denseinfo() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.denseinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::OSMPBF::DenseInfo>(GetArenaForAllocation());
    _impl_.denseinfo_ = p;
  }
  return _impl_.denseinfo_;
}
inline ::OSMPBF::DenseInfo* DenseNodes::mutable_denseinfo() {
  ::OSMPBF::DenseInfo* _msg = _internal_mutable_denseinfo();
  // @@protoc_insertion_point(field_mutable:OSMPBF.DenseNodes.denseinfo)
  return _msg;
}
inline void DenseNodes::set_allocated_denseinfo(::OSMPBF::DenseInfo* denseinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.denseinfo_;
  }
  if (denseinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(denseinfo);
    if (message_arena != submessage_arena) {
      denseinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, denseinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.denseinfo_ = denseinfo;
  // @@protoc_insertion_point(field_set_allocated:OSMPBF.DenseNodes.denseinfo)
}

// repeated sint64 lat = 8 [packed = true];
inline int DenseNodes::_internal_lat_size() const {
  return _impl_.lat_.size();
}
inline int DenseNodes::lat_size() const {
  return _internal_lat_size();
}
inline void DenseNodes::clear_lat() {
  _impl_.lat_.Clear();
}
inline int64_t DenseNodes::_internal_lat(int index) const {
  return _impl_.lat_.Get(index);
}
inline int64_t DenseNodes::lat(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.DenseNodes.lat)
  return _internal_lat(index);
}
inline void DenseNodes::set_lat(int index, int64_t value) {
  _impl_.lat_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.DenseNodes.lat)
}
inline void DenseNodes::_internal_add_lat(int64_t value) {
  _impl_.lat_.Add(value);
}
inline void DenseNodes::add_lat(int64_t value) {
  _internal_add_lat(value);
  // @@protoc_insertion_point(field_add:OSMPBF.DenseNodes.lat)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
DenseNodes::_internal_lat() const {
  return _impl_.lat_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
DenseNodes::lat() const {
  // @@protoc_insertion_point(field_list:OSMPBF.DenseNodes.lat)
  return _internal_lat();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
DenseNodes::_internal_mutable_lat() {
  return &_impl_.lat_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
DenseNodes::mutable_lat() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.DenseNodes.lat)
  return _internal_mutable_lat();
}

// repeated sint64 lon = 9 [packed = true];
inline int DenseNodes::_internal_lon_size() const {
  return _impl_.lon_.size();
}
inline int DenseNodes::lon_size() const {
  return _internal_lon_size();
}
inline void DenseNodes::clear_lon() {
  _impl_.lon_.Clear();
}
inline int64_t DenseNodes::_internal_lon(int index) const {
  return _impl_.lon_.Get(index);
}
inline int64_t DenseNodes::lon(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.DenseNodes.lon)
  return _internal_lon(index);
}
inline void DenseNodes::set_lon(int index, int64_t value) {
  _impl_.lon_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.DenseNodes.lon)
}
inline void DenseNodes::_internal_add_lon(int64_t value) {
  _impl_.lon_.Add(value);
}
inline void DenseNodes::add_lon(int64_t value) {
  _internal_add_lon(value);
  // @@protoc_insertion_point(field_add:OSMPBF.DenseNodes.lon)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
DenseNodes::_internal_lon() const {
  return _impl_.lon_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
DenseNodes::lon() const {
  // @@protoc_insertion_point(field_list:OSMPBF.DenseNodes.lon)
  return _internal_lon();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
DenseNodes::_internal_mutable_lon() {
  return &_impl_.lon_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
DenseNodes::mutable_lon() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.DenseNodes.lon)
  return _internal_mutable_lon();
}

// repeated int32 keys_vals = 10 [packed = true];
inline int DenseNodes::_internal_keys_vals_size() const {
  return _impl_.keys_vals_.size();
}
inline int DenseNodes::keys_vals_size() const {
  return _internal_keys_vals_size();
}
inline void DenseNodes::clear_keys_vals() {
  _impl_.keys_vals_.Clear();
}
inline int32_t DenseNodes::_internal_keys_vals(int index) const {
  return _impl_.keys_vals_.Get(index);
}
inline int32_t DenseNodes::keys_vals(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.DenseNodes.keys_vals)
  return _internal_keys_vals(index);
}
inline void DenseNodes::set_keys_vals(int index, int32_t value) {
  _impl_.keys_vals_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.DenseNodes.keys_vals)
}
inline void DenseNodes::_internal_add_keys_vals(int32_t value) {
  _impl_.keys_vals_.Add(value);
}
inline void DenseNodes::add_keys_vals(int32_t value) {
  _internal_add_keys_vals(value);
  // @@protoc_insertion_point(field_add:OSMPBF.DenseNodes.keys_vals)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
DenseNodes::_internal_keys_vals() const {
  return _impl_.keys_vals_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
DenseNodes::keys_vals() const {
  // @@protoc_insertion_point(field_list:OSMPBF.DenseNodes.keys_vals)
  return _internal_keys_vals();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
DenseNodes::_internal_mutable_keys_vals() {
  return &_impl_.keys_vals_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
DenseNodes::mutable_keys_vals() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.DenseNodes.keys_vals)
  return _internal_mutable_keys_vals();
}

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

// Way

// required int64 id = 1;
inline bool Way::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Way::has_id() const {
  return _internal_has_id();
}
inline void Way::clear_id() {
  _impl_.id_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t Way::_internal_id() const {
  return _impl_.id_;
}
inline int64_t Way::id() const {
  // @@protoc_insertion_point(field_get:OSMPBF.Way.id)
  return _internal_id();
}
inline void Way::_internal_set_id(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.id_ = value;
}
inline void Way::set_id(int64_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:OSMPBF.Way.id)
}

// repeated uint32 keys = 2 [packed = true];
inline int Way::_internal_keys_size() const {
  return _impl_.keys_.size();
}
inline int Way::keys_size() const {
  return _internal_keys_size();
}
inline void Way::clear_keys() {
  _impl_.keys_.Clear();
}
inline uint32_t Way::_internal_keys(int index) const {
  return _impl_.keys_.Get(index);
}
inline uint32_t Way::keys(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.Way.keys)
  return _internal_keys(index);
}
inline void Way::set_keys(int index, uint32_t value) {
  _impl_.keys_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.Way.keys)
}
inline void Way::_internal_add_keys(uint32_t value) {
  _impl_.keys_.Add(value);
}
inline void Way::add_keys(uint32_t value) {
  _internal_add_keys(value);
  // @@protoc_insertion_point(field_add:OSMPBF.Way.keys)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Way::_internal_keys() const {
  return _impl_.keys_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Way::keys() const {
  // @@protoc_insertion_point(field_list:OSMPBF.Way.keys)
  return _internal_keys();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Way::_internal_mutable_keys() {
  return &_impl_.keys_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Way::mutable_keys() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.Way.keys)
  return _internal_mutable_keys();
}

// repeated uint32 vals = 3 [packed = true];
inline int Way::_internal_vals_size() const {
  return _impl_.vals_.size();
}
inline int Way::vals_size() const {
  return _internal_vals_size();
}
inline void Way::clear_vals() {
  _impl_.vals_.Clear();
}
inline uint32_t Way::_internal_vals(int index) const {
  return _impl_.vals_.Get(index);
}
inline uint32_t Way::vals(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.Way.vals)
  return _internal_vals(index);
}
inline void Way::set_vals(int index, uint32_t value) {
  _impl_.vals_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.Way.vals)
}
inline void Way::_internal_add_vals(uint32_t value) {
  _impl_.vals_.Add(value);
}
inline void Way::add_vals(uint32_t value) {
  _internal_add_vals(value);
  // @@protoc_insertion_point(field_add:OSMPBF.Way.vals)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Way::_internal_vals() const {
  return _impl_.vals_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Way::vals() const {
  // @@protoc_insertion_point(field_list:OSMPBF.Way.vals)
  return _internal_vals();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Way::_internal_mutable_vals() {
  return &_impl_.vals_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Way::mutable_vals() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.Way.vals)
  return _internal_mutable_vals();
}

// optional .OSMPBF.Info info = 4;
inline bool Way::_internal_has_info() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.info_ != nullptr);
  return value;
}
inline bool Way::has_info() const {
  return _internal_has_info();
}
inline void Way::clear_info() {
  if (_impl_.info_ != nullptr) _impl_.info_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::OSMPBF::Info& Way::_internal_info() const {
  const ::OSMPBF::Info* p = _impl_.info_;
  return p != nullptr ? *p : reinterpret_cast<const ::OSMPBF::Info&>(
      ::OSMPBF::_Info_default_instance_);
}
inline const ::OSMPBF::Info& Way::info() const {
  // @@protoc_insertion_point(field_get:OSMPBF.Way.info)
  return _internal_info();
}
inline void Way::unsafe_arena_set_allocated_info(
    ::OSMPBF::Info* info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.info_);
  }
  _impl_.info_ = info;
  if (info) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:OSMPBF.Way.info)
}
inline ::OSMPBF::Info* Way::release_info() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::OSMPBF::Info* temp = _impl_.info_;
  _impl_.info_ = 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 ::OSMPBF::Info* Way::unsafe_arena_release_info() {
  // @@protoc_insertion_point(field_release:OSMPBF.Way.info)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::OSMPBF::Info* temp = _impl_.info_;
  _impl_.info_ = nullptr;
  return temp;
}
inline ::OSMPBF::Info* Way::_internal_mutable_info() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.info_ == nullptr) {
    auto* p = CreateMaybeMessage<::OSMPBF::Info>(GetArenaForAllocation());
    _impl_.info_ = p;
  }
  return _impl_.info_;
}
inline ::OSMPBF::Info* Way::mutable_info() {
  ::OSMPBF::Info* _msg = _internal_mutable_info();
  // @@protoc_insertion_point(field_mutable:OSMPBF.Way.info)
  return _msg;
}
inline void Way::set_allocated_info(::OSMPBF::Info* info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.info_;
  }
  if (info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(info);
    if (message_arena != submessage_arena) {
      info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, info, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.info_ = info;
  // @@protoc_insertion_point(field_set_allocated:OSMPBF.Way.info)
}

// repeated sint64 refs = 8 [packed = true];
inline int Way::_internal_refs_size() const {
  return _impl_.refs_.size();
}
inline int Way::refs_size() const {
  return _internal_refs_size();
}
inline void Way::clear_refs() {
  _impl_.refs_.Clear();
}
inline int64_t Way::_internal_refs(int index) const {
  return _impl_.refs_.Get(index);
}
inline int64_t Way::refs(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.Way.refs)
  return _internal_refs(index);
}
inline void Way::set_refs(int index, int64_t value) {
  _impl_.refs_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.Way.refs)
}
inline void Way::_internal_add_refs(int64_t value) {
  _impl_.refs_.Add(value);
}
inline void Way::add_refs(int64_t value) {
  _internal_add_refs(value);
  // @@protoc_insertion_point(field_add:OSMPBF.Way.refs)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
Way::_internal_refs() const {
  return _impl_.refs_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
Way::refs() const {
  // @@protoc_insertion_point(field_list:OSMPBF.Way.refs)
  return _internal_refs();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
Way::_internal_mutable_refs() {
  return &_impl_.refs_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
Way::mutable_refs() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.Way.refs)
  return _internal_mutable_refs();
}

// repeated sint64 lat = 9 [packed = true];
inline int Way::_internal_lat_size() const {
  return _impl_.lat_.size();
}
inline int Way::lat_size() const {
  return _internal_lat_size();
}
inline void Way::clear_lat() {
  _impl_.lat_.Clear();
}
inline int64_t Way::_internal_lat(int index) const {
  return _impl_.lat_.Get(index);
}
inline int64_t Way::lat(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.Way.lat)
  return _internal_lat(index);
}
inline void Way::set_lat(int index, int64_t value) {
  _impl_.lat_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.Way.lat)
}
inline void Way::_internal_add_lat(int64_t value) {
  _impl_.lat_.Add(value);
}
inline void Way::add_lat(int64_t value) {
  _internal_add_lat(value);
  // @@protoc_insertion_point(field_add:OSMPBF.Way.lat)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
Way::_internal_lat() const {
  return _impl_.lat_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
Way::lat() const {
  // @@protoc_insertion_point(field_list:OSMPBF.Way.lat)
  return _internal_lat();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
Way::_internal_mutable_lat() {
  return &_impl_.lat_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
Way::mutable_lat() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.Way.lat)
  return _internal_mutable_lat();
}

// repeated sint64 lon = 10 [packed = true];
inline int Way::_internal_lon_size() const {
  return _impl_.lon_.size();
}
inline int Way::lon_size() const {
  return _internal_lon_size();
}
inline void Way::clear_lon() {
  _impl_.lon_.Clear();
}
inline int64_t Way::_internal_lon(int index) const {
  return _impl_.lon_.Get(index);
}
inline int64_t Way::lon(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.Way.lon)
  return _internal_lon(index);
}
inline void Way::set_lon(int index, int64_t value) {
  _impl_.lon_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.Way.lon)
}
inline void Way::_internal_add_lon(int64_t value) {
  _impl_.lon_.Add(value);
}
inline void Way::add_lon(int64_t value) {
  _internal_add_lon(value);
  // @@protoc_insertion_point(field_add:OSMPBF.Way.lon)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
Way::_internal_lon() const {
  return _impl_.lon_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
Way::lon() const {
  // @@protoc_insertion_point(field_list:OSMPBF.Way.lon)
  return _internal_lon();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
Way::_internal_mutable_lon() {
  return &_impl_.lon_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
Way::mutable_lon() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.Way.lon)
  return _internal_mutable_lon();
}

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

// Relation

// required int64 id = 1;
inline bool Relation::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Relation::has_id() const {
  return _internal_has_id();
}
inline void Relation::clear_id() {
  _impl_.id_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t Relation::_internal_id() const {
  return _impl_.id_;
}
inline int64_t Relation::id() const {
  // @@protoc_insertion_point(field_get:OSMPBF.Relation.id)
  return _internal_id();
}
inline void Relation::_internal_set_id(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.id_ = value;
}
inline void Relation::set_id(int64_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:OSMPBF.Relation.id)
}

// repeated uint32 keys = 2 [packed = true];
inline int Relation::_internal_keys_size() const {
  return _impl_.keys_.size();
}
inline int Relation::keys_size() const {
  return _internal_keys_size();
}
inline void Relation::clear_keys() {
  _impl_.keys_.Clear();
}
inline uint32_t Relation::_internal_keys(int index) const {
  return _impl_.keys_.Get(index);
}
inline uint32_t Relation::keys(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.Relation.keys)
  return _internal_keys(index);
}
inline void Relation::set_keys(int index, uint32_t value) {
  _impl_.keys_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.Relation.keys)
}
inline void Relation::_internal_add_keys(uint32_t value) {
  _impl_.keys_.Add(value);
}
inline void Relation::add_keys(uint32_t value) {
  _internal_add_keys(value);
  // @@protoc_insertion_point(field_add:OSMPBF.Relation.keys)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Relation::_internal_keys() const {
  return _impl_.keys_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Relation::keys() const {
  // @@protoc_insertion_point(field_list:OSMPBF.Relation.keys)
  return _internal_keys();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Relation::_internal_mutable_keys() {
  return &_impl_.keys_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Relation::mutable_keys() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.Relation.keys)
  return _internal_mutable_keys();
}

// repeated uint32 vals = 3 [packed = true];
inline int Relation::_internal_vals_size() const {
  return _impl_.vals_.size();
}
inline int Relation::vals_size() const {
  return _internal_vals_size();
}
inline void Relation::clear_vals() {
  _impl_.vals_.Clear();
}
inline uint32_t Relation::_internal_vals(int index) const {
  return _impl_.vals_.Get(index);
}
inline uint32_t Relation::vals(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.Relation.vals)
  return _internal_vals(index);
}
inline void Relation::set_vals(int index, uint32_t value) {
  _impl_.vals_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.Relation.vals)
}
inline void Relation::_internal_add_vals(uint32_t value) {
  _impl_.vals_.Add(value);
}
inline void Relation::add_vals(uint32_t value) {
  _internal_add_vals(value);
  // @@protoc_insertion_point(field_add:OSMPBF.Relation.vals)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Relation::_internal_vals() const {
  return _impl_.vals_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Relation::vals() const {
  // @@protoc_insertion_point(field_list:OSMPBF.Relation.vals)
  return _internal_vals();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Relation::_internal_mutable_vals() {
  return &_impl_.vals_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Relation::mutable_vals() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.Relation.vals)
  return _internal_mutable_vals();
}

// optional .OSMPBF.Info info = 4;
inline bool Relation::_internal_has_info() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.info_ != nullptr);
  return value;
}
inline bool Relation::has_info() const {
  return _internal_has_info();
}
inline void Relation::clear_info() {
  if (_impl_.info_ != nullptr) _impl_.info_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::OSMPBF::Info& Relation::_internal_info() const {
  const ::OSMPBF::Info* p = _impl_.info_;
  return p != nullptr ? *p : reinterpret_cast<const ::OSMPBF::Info&>(
      ::OSMPBF::_Info_default_instance_);
}
inline const ::OSMPBF::Info& Relation::info() const {
  // @@protoc_insertion_point(field_get:OSMPBF.Relation.info)
  return _internal_info();
}
inline void Relation::unsafe_arena_set_allocated_info(
    ::OSMPBF::Info* info) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.info_);
  }
  _impl_.info_ = info;
  if (info) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:OSMPBF.Relation.info)
}
inline ::OSMPBF::Info* Relation::release_info() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::OSMPBF::Info* temp = _impl_.info_;
  _impl_.info_ = 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 ::OSMPBF::Info* Relation::unsafe_arena_release_info() {
  // @@protoc_insertion_point(field_release:OSMPBF.Relation.info)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::OSMPBF::Info* temp = _impl_.info_;
  _impl_.info_ = nullptr;
  return temp;
}
inline ::OSMPBF::Info* Relation::_internal_mutable_info() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.info_ == nullptr) {
    auto* p = CreateMaybeMessage<::OSMPBF::Info>(GetArenaForAllocation());
    _impl_.info_ = p;
  }
  return _impl_.info_;
}
inline ::OSMPBF::Info* Relation::mutable_info() {
  ::OSMPBF::Info* _msg = _internal_mutable_info();
  // @@protoc_insertion_point(field_mutable:OSMPBF.Relation.info)
  return _msg;
}
inline void Relation::set_allocated_info(::OSMPBF::Info* info) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.info_;
  }
  if (info) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(info);
    if (message_arena != submessage_arena) {
      info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, info, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.info_ = info;
  // @@protoc_insertion_point(field_set_allocated:OSMPBF.Relation.info)
}

// repeated int32 roles_sid = 8 [packed = true];
inline int Relation::_internal_roles_sid_size() const {
  return _impl_.roles_sid_.size();
}
inline int Relation::roles_sid_size() const {
  return _internal_roles_sid_size();
}
inline void Relation::clear_roles_sid() {
  _impl_.roles_sid_.Clear();
}
inline int32_t Relation::_internal_roles_sid(int index) const {
  return _impl_.roles_sid_.Get(index);
}
inline int32_t Relation::roles_sid(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.Relation.roles_sid)
  return _internal_roles_sid(index);
}
inline void Relation::set_roles_sid(int index, int32_t value) {
  _impl_.roles_sid_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.Relation.roles_sid)
}
inline void Relation::_internal_add_roles_sid(int32_t value) {
  _impl_.roles_sid_.Add(value);
}
inline void Relation::add_roles_sid(int32_t value) {
  _internal_add_roles_sid(value);
  // @@protoc_insertion_point(field_add:OSMPBF.Relation.roles_sid)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
Relation::_internal_roles_sid() const {
  return _impl_.roles_sid_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
Relation::roles_sid() const {
  // @@protoc_insertion_point(field_list:OSMPBF.Relation.roles_sid)
  return _internal_roles_sid();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
Relation::_internal_mutable_roles_sid() {
  return &_impl_.roles_sid_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
Relation::mutable_roles_sid() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.Relation.roles_sid)
  return _internal_mutable_roles_sid();
}

// repeated sint64 memids = 9 [packed = true];
inline int Relation::_internal_memids_size() const {
  return _impl_.memids_.size();
}
inline int Relation::memids_size() const {
  return _internal_memids_size();
}
inline void Relation::clear_memids() {
  _impl_.memids_.Clear();
}
inline int64_t Relation::_internal_memids(int index) const {
  return _impl_.memids_.Get(index);
}
inline int64_t Relation::memids(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.Relation.memids)
  return _internal_memids(index);
}
inline void Relation::set_memids(int index, int64_t value) {
  _impl_.memids_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.Relation.memids)
}
inline void Relation::_internal_add_memids(int64_t value) {
  _impl_.memids_.Add(value);
}
inline void Relation::add_memids(int64_t value) {
  _internal_add_memids(value);
  // @@protoc_insertion_point(field_add:OSMPBF.Relation.memids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
Relation::_internal_memids() const {
  return _impl_.memids_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
Relation::memids() const {
  // @@protoc_insertion_point(field_list:OSMPBF.Relation.memids)
  return _internal_memids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
Relation::_internal_mutable_memids() {
  return &_impl_.memids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
Relation::mutable_memids() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.Relation.memids)
  return _internal_mutable_memids();
}

// repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];
inline int Relation::_internal_types_size() const {
  return _impl_.types_.size();
}
inline int Relation::types_size() const {
  return _internal_types_size();
}
inline void Relation::clear_types() {
  _impl_.types_.Clear();
}
inline ::OSMPBF::Relation_MemberType Relation::_internal_types(int index) const {
  return static_cast< ::OSMPBF::Relation_MemberType >(_impl_.types_.Get(index));
}
inline ::OSMPBF::Relation_MemberType Relation::types(int index) const {
  // @@protoc_insertion_point(field_get:OSMPBF.Relation.types)
  return _internal_types(index);
}
inline void Relation::set_types(int index, ::OSMPBF::Relation_MemberType value) {
  assert(::OSMPBF::Relation_MemberType_IsValid(value));
  _impl_.types_.Set(index, value);
  // @@protoc_insertion_point(field_set:OSMPBF.Relation.types)
}
inline void Relation::_internal_add_types(::OSMPBF::Relation_MemberType value) {
  assert(::OSMPBF::Relation_MemberType_IsValid(value));
  _impl_.types_.Add(value);
}
inline void Relation::add_types(::OSMPBF::Relation_MemberType value) {
  _internal_add_types(value);
  // @@protoc_insertion_point(field_add:OSMPBF.Relation.types)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
Relation::types() const {
  // @@protoc_insertion_point(field_list:OSMPBF.Relation.types)
  return _impl_.types_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
Relation::_internal_mutable_types() {
  return &_impl_.types_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
Relation::mutable_types() {
  // @@protoc_insertion_point(field_mutable_list:OSMPBF.Relation.types)
  return _internal_mutable_types();
}

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace OSMPBF

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::OSMPBF::Relation_MemberType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::OSMPBF::Relation_MemberType>() {
  return ::OSMPBF::Relation_MemberType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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